@3cr/viewer-browser 0.0.161 → 0.0.194

package/src/dataLayer/__tests__/viewer3cr.spec.ts

@@ -0,0 +1,331 @@
+import {beforeEach, describe, expect, it, MockInstance, vi} from "vitest";
+import {emptyPayload, Viewer3cr} from "@/dataLayer/viewer3cr";
+import {unref} from "vue";
+import {
+  AnchorPoint,
+  DataOverlayActions,
+  FrontEndInterfaces, InteractivityActions,
+  LayoutActions, NavigationCubeActions,
+  PresetsActions,
+  ScanMovementActions,
+  ScanOrientationActions,
+  ScanView,
+  SlidersActions,
+} from "@3cr/types-ts";
+import {toNumber} from "@/helpers/utils";
+import {currentColourPreset, previousLayout, transactionStarted,} from "@/dataLayer/scanState";
+import {useViewer3cr} from "@/dataLayer/useViewer3cr";
+
+describe('Viewer3cr tests', () => {
+  const viewer3cr = useViewer3cr();
+
+  let sendPayload: MockInstance;
+
+  beforeEach(() => {
+    sendPayload = vi.spyOn(Viewer3cr.prototype, 'sendPayload').mockResolvedValue();
+  });
+
+  it('should create instance', () => {
+    expect(viewer3cr).toBeTruthy();
+  });
+
+  describe('data overlay actions', () => {
+    it('should toggle 2d annotation', async () => {
+      await viewer3cr.toggle2dAnnotation('test', true);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.data_overlay, DataOverlayActions.do03, {
+        Version: expect.any(String),
+        Id: 'test',
+        Visibility: true
+      });
+    });
+
+    it('should toggle 3d annotation', async () => {
+      await viewer3cr.toggle3dAnnotation('test', true);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.data_overlay, DataOverlayActions.do11, {
+        Version: expect.any(String),
+        Id: 'test',
+        Visibility: true
+      });
+    });
+  });
+
+  describe('interactivity actions', () => {
+    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
+      });
+    });
+  });
+
+  describe('layout actions', () => {
+    beforeEach(() => {
+      previousLayout.value = LayoutActions.lo01;
+    });
+
+    it('should layouts', async () => {
+      const action = LayoutActions.lo01;
+      expect(sendPayload).not.toHaveBeenCalled();
+      await viewer3cr.layouts(action);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.layout, action, emptyPayload);
+    });
+
+    it('should set prevLayout', async () => {
+      const action = LayoutActions.lo02;
+      expect(sendPayload).not.toHaveBeenCalled();
+      expect(unref(previousLayout)).not.toBe(LayoutActions.lo02);
+      await viewer3cr.layouts(action);
+      expect(unref(previousLayout)).toBe(LayoutActions.lo02);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.layout, action, emptyPayload);
+    });
+  });
+
+  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 }
+      });
+    });
+
+    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
+      });
+    });
+
+    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
+      });
+    });
+
+    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
+      });
+    });
+
+    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
+      });
+    });
+  });
+
+  describe('preset actions', () => {
+    it("should set setPreset", async () => {
+      const action = PresetsActions.pr01;
+      const data = { asd: "123" };
+      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);
+    });
+
+    it("should set setPreset change colour", async () => {
+      const action = PresetsActions.pr02;
+      const data = { asd: "123", };
+      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);
+    });
+  });
+
+  describe('scan movement actions', () => {
+    it("should scanMovementHandler", async () => {
+      const action = ScanMovementActions.sm05;
+      const value = 100;
+      expect(sendPayload).not.toHaveBeenCalled();
+      await viewer3cr.scanMovementHandler(action, value);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.scan_movement, action, {
+        Version: expect.any(String),
+        Value: toNumber(value),
+      });
+    });
+
+    it("should not scanMovementHandler transactionStarted", async () => {
+      transactionStarted.value = true;
+      const action = ScanMovementActions.sm05;
+      const value = 100;
+      expect(sendPayload).not.toHaveBeenCalled();
+      await viewer3cr.scanMovementHandler(action, value);
+      expect(sendPayload).not.toHaveBeenCalledWith(FrontEndInterfaces.scan_movement, action, {
+        Version: expect.any(String),
+        Value: toNumber(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,
+      });
+    });
+
+    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,
+      });
+    });
+
+    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,
+      });
+    });
+
+    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,
+      });
+    });
+
+    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,
+      });
+    });
+
+    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,
+      });
+    });
+  });
+
+  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,
+      });
+    });
+
+    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
+      });
+    });
+
+    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
+      });
+    });
+
+    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
+      });
+    });
+  });
+
+  describe('slider actions', () => {
+    beforeEach(() => {
+      transactionStarted.value = false;
+    });
+
+    it("should sliderHandler", async () => {
+      const action = SlidersActions.sl08;
+      const value = 100;
+      expect(sendPayload).not.toHaveBeenCalled();
+      await viewer3cr.sliderHandler(action, value);
+      expect(sendPayload).toHaveBeenCalledWith(FrontEndInterfaces.sliders, action, {
+        Version: expect.any(String),
+        Value: toNumber(value),
+      });
+    });
+
+    it("should not sliderHandler transactionStarted", async () => {
+      transactionStarted.value = true;
+      const action = SlidersActions.sl08;
+      const value = 100;
+      expect(sendPayload).not.toHaveBeenCalled();
+      await viewer3cr.sliderHandler(action, value);
+      expect(sendPayload).not.toHaveBeenCalledWith(FrontEndInterfaces.sliders, action, {
+        Version: expect.any(String),
+        Value: toNumber(value),
+      });
+    });
+  });
+});

package/src/dataLayer/clamp.ts

@@ -0,0 +1,9 @@
+/**
+ * Clamps a number to min if value < min, or max if value > max, otherwise return value.
+ * @param value The value to clamp
+ * @param min The minimum value.
+ * @param max The maximum value.
+ */
+export function clamp(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max);
+}

package/src/dataLayer/eventHandlers.ts

@@ -0,0 +1,26 @@
+export class EventHandlers<Key, Callback extends CallableFunction> {
+  private callbacks = new Map<Key, Set<Callback>>();
+
+  add(key: Key, callback: Callback): void {
+    if (this.callbacks.has(key)) {
+      this.callbacks.get(key)!.add(callback);
+    } else {
+      this.callbacks.set(key, new Set([callback]));
+    }
+  }
+
+  remove(key: Key, callback: Callback): boolean {
+    if (this.callbacks.has(key)) {
+      return this.callbacks.get(key)!.delete(callback);
+    }
+    return false;
+  }
+
+  async call(key: Key, ...args: unknown[]): Promise<void> {
+    if (this.callbacks.has(key)) {
+      for (const callback of this.callbacks.get(key)!) {
+        await callback(...args);
+      }
+    }
+  }
+}

package/src/dataLayer/patchDataOverlay.ts

@@ -0,0 +1,101 @@
+import {
+  Action,
+  ActionData,
+  CallToAction,
+  CurrentDataOverlayState,
+  DataOverlay,
+  DataOverlayData, DataOverlayEvent,
+  InitialDataOverlayState
+} from "@3cr/types-ts";
+
+export type DataOverlayDataUnpatched = Omit<DataOverlayData, 'Data'> & {
+  Data: string;
+};
+
+export type DataOverlayUnpatched = Omit<DataOverlay, 'CallToAction'> & {
+  CallToAction: string | null;
+};
+
+export type CallToActionUnpatched = Omit<CallToAction, 'Actions'> & {
+  Actions: ActionUnpatched[];
+};
+
+export type ActionUnpatched = Omit<Action, 'ActionData'> & {
+  ActionData: string;
+};
+
+export type CurrentDataOverlayStateUnpatched = Omit<CurrentDataOverlayState, 'DataOverlay'> & {
+  DataOverlay: DataOverlayDataUnpatched[];
+};
+
+export type InitialDataOverlayStateUnpatched = Omit<InitialDataOverlayState, 'DataOverlay'> & {
+  DataOverlay: CurrentDataOverlayStateUnpatched;
+};
+
+export type DataOverlayEventUnpatched = Omit<DataOverlayEvent, 'Annotation'> & {
+  Annotation: DataOverlayUnpatched;
+}
+
+export function patchAction(data: ActionUnpatched) {
+  return {
+    ...data,
+    ActionData: JSON.parse(data.ActionData) as ActionData
+  };
+}
+
+export function patchDataOverlay(data: DataOverlayUnpatched) {
+  return {
+    ...data,
+    CallToAction: data.CallToAction ? JSON.parse(data.CallToAction) as CallToActionUnpatched : null
+  };
+}
+
+export function patchDataOverlayData(data: DataOverlayDataUnpatched) {
+  return {
+    ...data,
+    Data: JSON.parse(data.Data) as DataOverlayUnpatched
+  }
+}
+
+export function patchInitialDataOverlay(data: InitialDataOverlayStateUnpatched): InitialDataOverlayState {
+  return {
+    ...data,
+    DataOverlay: patchCurrentDataOverlay(data.DataOverlay)
+  };
+}
+
+export function patchCurrentDataOverlay(data: CurrentDataOverlayStateUnpatched): CurrentDataOverlayState {
+  return {
+    ...data,
+    DataOverlay: data.DataOverlay.map(overlay => {
+      const patchedDataOverlayData = patchDataOverlayData(overlay);
+      const patchedDataOverlay = patchDataOverlay(patchedDataOverlayData.Data);
+      return {
+        ...patchedDataOverlayData,
+        Data: {
+          ...patchedDataOverlay,
+          CallToAction: patchedDataOverlay.CallToAction ? {
+            Actions: patchedDataOverlay.CallToAction.Actions.map(action => {
+              return patchAction(action);
+            })
+          } : null
+        }
+      };
+    })
+  };
+}
+
+export function patchDataOverlayEvent(data: DataOverlayEventUnpatched): DataOverlayEvent {
+  const patchedDataOverlay = patchDataOverlay(data.Annotation);
+  return {
+    ...data,
+    Annotation: {
+      ...patchedDataOverlay,
+      CallToAction: patchedDataOverlay.CallToAction ? {
+        Actions: patchedDataOverlay.CallToAction.Actions.map(action => {
+          return patchAction(action);
+        })
+      } : null
+    }
+  };
+}