@3cr/viewer-browser 0.0.200 → 0.0.246

package/src/{dataLayer → models}/scanState.ts

@@ -1,117 +1,106 @@
-import { computed, nextTick, ref, unref } from "vue";
+import { computed, nextTick, ref, unref } from 'vue';
 import {
   AnchorPoint,
+  DataOverlayData,
   ColourPresetData,
+  CurrentDataOverlayState,
+  CurrentMcadState,
   CurrentScanState,
-  DataOverlayEvent,
   InitialDataOverlayState,
+  InitialMcadState,
   InitialScanState,
   LayoutActions,
+  McadInteraction,
   PositionData,
-  ScanView,
-} from "@3cr/types-ts";
-import { inflateInitialDataOverlayState, inflateInitialScanState, inflateScanState } from "@/helpers/modelHelper";
+  ScanView
+} from '@3cr/types-ts';
 import {
-  CurrentDataOverlayStateUnpatched,
-  DataOverlayEventUnpatched,
-  InitialDataOverlayStateUnpatched,
-  patchCurrentDataOverlay,
-  patchDataOverlayEvent,
-  patchInitialDataOverlay
-} from "@/dataLayer/patchDataOverlay";
+  inflateInitialDataOverlayState,
+  inflateInitialMcadObjectState,
+  inflateInitialScanState,
+  inflateScanState
+} from '@/functions/modelHelper';
 
 export const currentColourPreset = ref<ColourPresetData | undefined>(undefined);
 export const transactionStarted = ref<boolean>(false);
-export const scanStateIncoming = ref<string>("");
+export const scanStateIncoming = ref<string>('');
+export const initialScanState = ref<InitialScanState>(inflateInitialScanState());
 export const scanState = ref<CurrentScanState>(inflateScanState());
-export const dataOverlayEvent = ref<DataOverlayEvent | null>(null);
+export const stlResolution = ref<number>(5);
 export const dataOverlayState = ref<InitialDataOverlayState>(inflateInitialDataOverlayState());
-export const initialScanState = ref<InitialScanState>(inflateInitialScanState());
+export const dataOverlayEvent = ref<DataOverlayData | null>(null);
+export const mcadObjectState = ref<InitialMcadState>(inflateInitialMcadObjectState());
+export const mcadObjectEvent = ref<McadInteraction | null>(null);
 export const previousLayout = ref<LayoutActions>(LayoutActions.lo02);
 
 export const huMinMax = ref({
   min: -999999,
-  max: 999999,
+  max: 999999
 });
 
 export const tMinMax = ref({
   min: 0,
-  max: 999999,
+  max: 999999
 });
 
 export const sMinMax = ref({
   min: 0,
-  max: 999999,
+  max: 999999
 });
 
 export const cMinMax = ref({
   min: 0,
-  max: 999999,
+  max: 999999
 });
 
 export const windowSlider = computed({
   get(): [number, number] {
-    return [
-      unref(scanState).Display.WindowLower,
-      unref(scanState).Display.WindowUpper,
-    ];
+    return [unref(scanState).Display.WindowLower, unref(scanState).Display.WindowUpper];
   },
   set(value: [number, number]): void {
     scanState.value.Display.WindowLower = value[0];
     scanState.value.Display.WindowUpper = value[1];
-  },
+  }
 });
 
 export const thresholdSlider = computed({
   get(): [number, number] {
-    return [
-      Math.trunc(unref(scanState).Display.ThresholdLower),
-      Math.trunc(unref(scanState).Display.ThresholdUpper),
-    ];
+    return [Math.trunc(unref(scanState).Display.ThresholdLower), Math.trunc(unref(scanState).Display.ThresholdUpper)];
   },
   set(value: [number, number]): void {
     scanState.value.Display.ThresholdLower = value[0];
     scanState.value.Display.ThresholdUpper = value[1];
-  },
+  }
 });
 
 export const tSlider = computed({
   get(): [number, number] {
-    return [
-      Math.trunc(unref(scanState).Slice.TransverseLower),
-      Math.trunc(unref(scanState).Slice.TransverseUpper),
-    ];
+    return [Math.trunc(unref(scanState).Slice.TransverseLower), Math.trunc(unref(scanState).Slice.TransverseUpper)];
   },
   set(value: [number, number]): void {
     scanState.value.Slice.TransverseLower = value[0];
     scanState.value.Slice.TransverseUpper = value[1];
-  },
+  }
 });
 
 export const sSlider = computed({
   get(): [number, number] {
-    return [
-      Math.trunc(unref(scanState).Slice.SagittalLower),
-      Math.trunc(unref(scanState).Slice.SagittalUpper),
-    ];
+    return [Math.trunc(unref(scanState).Slice.SagittalLower), Math.trunc(unref(scanState).Slice.SagittalUpper)];
   },
   set(value: [number, number]): void {
     scanState.value.Slice.SagittalLower = value[0];
     scanState.value.Slice.SagittalUpper = value[1];
-  },
+  }
 });
 
 export const cSlider = computed({
   get(): [number, number] {
-    return [
-      Math.trunc(unref(scanState).Slice.CoronalLower),
-      Math.trunc(unref(scanState).Slice.CoronalUpper),
-    ];
+    return [Math.trunc(unref(scanState).Slice.CoronalLower), Math.trunc(unref(scanState).Slice.CoronalUpper)];
   },
   set(value: [number, number]): void {
     scanState.value.Slice.CoronalLower = value[0];
     scanState.value.Slice.CoronalUpper = value[1];
-  },
+  }
 });
 
 export const isLayout2x2 = computed(() => {
@@ -119,8 +108,7 @@ export const isLayout2x2 = computed(() => {
     unref(scanState).Layout.PositionData.length > 1 &&
     unref(scanState).Layout.PositionData[0].Anchor === AnchorPoint.TOP_LEFT &&
     unref(scanState).Layout.PositionData[1].Anchor === AnchorPoint.TOP_RIGHT &&
-    unref(scanState).Layout.PositionData[2].Anchor ===
-      AnchorPoint.BOTTOM_LEFT &&
+    unref(scanState).Layout.PositionData[2].Anchor === AnchorPoint.BOTTOM_LEFT &&
     unref(scanState).Layout.PositionData[3].Anchor === AnchorPoint.BOTTOM_RIGHT
   );
 });
@@ -139,21 +127,15 @@ export const isFullscreen = computed(() => {
   return unref(scanState).Layout.PositionData.length === 1;
 });
 
-export const isSessionLoaded = computed(() => {
-  return unref(dataOverlayState).DataOverlay.DataOverlay.length > 0;
-});
-
 export const currentGreyscalePreset = computed(() => {
   for (const preset of unref(initialScanState).GreyscalePresets) {
     if (
       (unref(scanState).Display.WindowLower === preset.Lower ||
         (preset.Lower < unref(initialScanState).HuLower &&
-          unref(scanState).Display.WindowLower ===
-            unref(initialScanState).HuLower)) &&
+          unref(scanState).Display.WindowLower === unref(initialScanState).HuLower)) &&
       (unref(scanState).Display.WindowUpper === preset.Upper ||
         (preset.Upper > unref(initialScanState).HuUpper &&
-          unref(scanState).Display.WindowUpper ===
-            unref(initialScanState).HuUpper))
+          unref(scanState).Display.WindowUpper === unref(initialScanState).HuUpper))
     ) {
       return preset;
     }
@@ -161,7 +143,7 @@ export const currentGreyscalePreset = computed(() => {
   return undefined;
 });
 
-export async function setScanStateFromPayload(message: string) {
+export async function setScanStateFromPayload(message: string): Promise<void> {
   transactionStarted.value = true;
   scanStateIncoming.value = JSON.stringify(JSON.parse(message), null, 2);
   setScanState(message);
@@ -169,7 +151,7 @@ export async function setScanStateFromPayload(message: string) {
   transactionStarted.value = false;
 }
 
-export function setInitialScanStateFromPayload(message: string) {
+export function setInitialScanStateFromPayload(message: string): void {
   transactionStarted.value = true;
   scanStateIncoming.value = JSON.stringify(JSON.parse(message), null, 2);
   const obj = JSON.parse(unref(scanStateIncoming)) as InitialScanState;
@@ -183,43 +165,50 @@ export function setInitialScanStateFromPayload(message: string) {
   currentColourPreset.value = obj.ColourPresets[0];
 }
 
-export function setScanState(message: string) {
+export function setScanState(message: string): void {
   scanState.value = JSON.parse(message) as CurrentScanState;
 }
 
-export function setInitialDataOverlayState(message: string) {
-  const data = JSON.parse(message) as InitialDataOverlayStateUnpatched;
-  dataOverlayState.value = patchInitialDataOverlay(data);
+export function setInitialDataOverlayState(message: string): void {
+  dataOverlayState.value = JSON.parse(message) as InitialDataOverlayState;
+}
+
+export function setDataOverlayState(message: string): void {
+  dataOverlayState.value = { Version: '1.1.0', DataOverlay: JSON.parse(message) as CurrentDataOverlayState };
+}
+
+export function setDataOverlayEvent(message: string): void {
+  dataOverlayEvent.value = JSON.parse(message) as DataOverlayData;
+}
+
+export function setInitialMcadState(message: string): void {
+  mcadObjectState.value = JSON.parse(message) as InitialMcadState;
 }
 
-export function setDataOverlayState(message: string) {
-  const data = JSON.parse(message) as CurrentDataOverlayStateUnpatched;
-  dataOverlayState.value = { Version: '1.1.0', DataOverlay: patchCurrentDataOverlay(data) };
+export function setMcadState(message: string): void {
+  mcadObjectState.value = { Version: '1.1.0', Models: JSON.parse(message) as CurrentMcadState };
 }
 
-export function setActiveAnnotation(message: string): void {
-  const data = JSON.parse(message) as DataOverlayEventUnpatched;
-  dataOverlayEvent.value = patchDataOverlayEvent(data);
+export function setMcadEvent(message: string): void {
+  mcadObjectEvent.value = JSON.parse(message) as McadInteraction;
 }
 
 export function getCurrentView(position: PositionData): ScanView {
-  return unref(scanState).Layout.PositionData.length !== 1
-    ? position.DefaultView
-    : unref(scanState).CurrentView;
+  return unref(scanState).Layout.PositionData.length !== 1 ? position.DefaultView : unref(scanState).CurrentView;
 }
 
 export function getViewName(view: ScanView): string {
   switch (view) {
     case ScanView.Coronal:
-      return "Coronal";
+      return 'Coronal';
     case ScanView.Sagittal:
-      return "Sagittal";
+      return 'Sagittal';
     case ScanView.Transverse:
-      return "Transverse";
+      return 'Transverse';
     case ScanView.Volume:
-      return "3D Volume";
+      return '3D Volume';
     default:
-      return "";
+      return '';
   }
 }
 

package/src/plugins/__tests__/usePlugins.spec.ts

@@ -0,0 +1,12 @@
+import vuetify from '@/plugins/vuetify';
+import { usePlugins } from '@/plugins/usePlugins';
+import { App } from 'vue';
+
+describe('usePlugins tests', () => {
+  it('should use plugins', () => {
+    const app = { use: vi.fn() } as unknown as App;
+    expect(app.use).not.toHaveBeenCalledWith(vuetify);
+    usePlugins(app);
+    expect(app.use).toHaveBeenCalledWith(vuetify);
+  });
+});

package/src/plugins/__tests__/vuetify.spec.ts

@@ -1,8 +1,7 @@
-import { describe, expect, it } from "vitest";
-import vuetify from "@/plugins/vuetify";
+import vuetify from '@/plugins/vuetify';
 
-describe("vuetify.ts", () => {
-  it("should vuetify base", () => {
+describe('vuetify.ts', () => {
+  it('should vuetify base', () => {
     expect(vuetify).toBeTruthy();
   });
 });

package/src/plugins/usePlugins.ts

@@ -0,0 +1,8 @@
+import type { App } from 'vue';
+import vuetify from './vuetify';
+import Notifications from '@kyvg/vue3-notification';
+
+export function usePlugins(app: App): void {
+  app.use(vuetify);
+  app.use(Notifications);
+}

package/src/plugins/vuetify.ts

@@ -1,75 +1,41 @@
-/**
- * plugins/vuetify.ts
- *
- * Framework documentation: https://vuetifyjs.com`
- */
-
-// Styles
-import "@/assets/styles.scss";
-
-// Composables
-import { createVuetify, IconProps } from "vuetify";
-import { aliases, md } from "vuetify/iconsets/md";
-import { mdi } from "vuetify/iconsets/mdi";
-import { fa } from "vuetify/iconsets/fa";
-import { h, ref } from "vue";
-import liver from "@/components/icons/liver.vue";
+import '@/assets/styles.scss';
+import { createVuetify } from 'vuetify';
+import { aliases, md } from 'vuetify/iconsets/md';
+import { mdi } from 'vuetify/iconsets/mdi';
 import { VTreeview, VTreeviewItem } from 'vuetify/labs/components';
 
-const customComponents: any = {
-  liver,
-};
-export const disableTheme = ref<boolean>(false);
-// https://vuetifyjs.com/en/introduction/why-vuetify/#feature-guides
-/* istanbul ignore next  -- @preserve */
 export default createVuetify({
   components: {
     VTreeview,
     VTreeviewItem
   },
-  theme: disableTheme.value
-    ? false
-    : {
-        defaultTheme: "__light",
-        themes: {
-          __light: {
-            dark: false,
-            colors: {
-              background: "#FFFFFF",
-              surface: "#FFFFFF",
-              "surface-bright": "#FFFFFF",
-              "surface-light": "#EEEEEE",
-              "surface-variant": "#424242",
-              "on-surface-variant": "#EEEEEE",
-              primary: "#1867C0",
-              "primary-darken-1": "#1F5592",
-              secondary: "#48A9A6",
-              "secondary-darken-1": "#018786",
-              error: "#B00020",
-              info: "#2196F3",
-              success: "#4CAF50",
-              warning: "#FB8C00",
-            },
-          },
-          light: {},
-          dark: {},
-        },
-      },
+  theme: {
+    defaultTheme: 'light',
+    themes: {
+      light: {
+        dark: false,
+        colors: {
+          background: '#FFFFFF',
+          surface: '#FFFFFF',
+          'surface-bright': '#FFFFFF',
+          'surface-light': '#EEEEEE',
+          'surface-variant': '#424242',
+          'on-surface-variant': '#EEEEEE',
+          primary: '#1867C0',
+          'primary-darken-1': '#1F5592',
+          secondary: '#48A9A6',
+          'secondary-darken-1': '#018786',
+          error: '#B00020',
+          info: '#2196F3',
+          success: '#4CAF50',
+          warning: '#FB8C00'
+        }
+      }
+    }
+  },
   icons: {
-    defaultSet: "md",
+    defaultSet: 'md',
     aliases,
-    sets: {
-      md,
-      mdi,
-      fa,
-      custom: {
-        /* c8 ignore start */
-        component: (props: IconProps) =>
-          h(props.tag, [
-            h(customComponents[props.icon as string], { class: "v-icon__svg" }),
-          ]),
-        /* c8 ignore stop */
-      },
-    },
-  },
+    sets: { md, mdi }
+  }
 });

package/src/services/{gpt/__tests__ → __tests__}/gpt.service.spec.ts

@@ -1,5 +1,5 @@
-import {describe, expect, it, vi} from "vitest";
-import {GptResponsePayload, GptService} from "@/services/gpt/gpt.service";
+import { GptService } from '@/services/gpt.service';
+import { GptResponsePayload } from '@/types/gpt-response-payload';
 
 vi.mock('axios', async (importOriginal) => {
   return {

package/src/services/__tests__/service-worker.service.spec.ts

@@ -0,0 +1,32 @@
+import { ServiceWorkerService } from '@/services/service-worker.service';
+
+const navigator: any = {
+  serviceWorker: {
+    getRegistration: vi.fn().mockReturnValue({
+      addEventListener: vi.fn(),
+      installing: {
+        addEventListener: vi.fn()
+      },
+      waiting: {},
+      update: vi.fn()
+    })
+  }
+};
+
+describe('ServiceWorkerService service tests', () => {
+  it('should instantiate', () => {
+    expect(ServiceWorkerService.Instantiate()).toBeTruthy();
+  });
+
+  it('should get registration', () => {
+    vi.spyOn(global, 'navigator', 'get').mockReturnValue(navigator);
+    const registration = ServiceWorkerService.Instantiate().getRegistration();
+    expect(registration).toBeTruthy();
+  });
+
+  it('should not get registration', async () => {
+    vi.spyOn(global, 'navigator', 'get').mockReturnValue({} as any);
+    const registration = await ServiceWorkerService.Instantiate().getRegistration();
+    expect(registration).toBeFalsy();
+  });
+});