@3cr/viewer-browser 0.0.248 → 0.0.292

package/src/stores/tool.store.ts

@@ -0,0 +1,41 @@
+import { defineStore } from 'pinia';
+import { useMcadSelectTool } from '@/tools/mcad-select-tool';
+import { useAnnotationCreateTool } from '@/tools/annotation-create.tool';
+import { useAnnotationMoveTool } from '@/tools/annotation-move.tool';
+import { useDataOverlayTool } from '@/tools/data-overlay.tool';
+import { useMeasurementAngleTool } from '@/tools/measurement-angle.tool';
+import { useMeasurementLengthTool } from '@/tools/measurement-length.tool';
+import { useMeasurementPolygonTool } from '@/tools/measurement-polygon.tool';
+import { useMcadMoveTool } from '@/tools/mcad-move.tool';
+import { useMcadRotateTool } from '@/tools/mcad-rotate.tool';
+import { useMcadScaleTool } from '@/tools/mcad-scale-tool';
+import { shallowRef } from 'vue';
+
+/**
+ * Store for singleton tool instances.
+ */
+export const useToolStore = defineStore('tool', () => {
+  const annotationCreateTool = shallowRef(useAnnotationCreateTool());
+  const annotationMoveTool = shallowRef(useAnnotationMoveTool());
+  const dataOverlayTool = shallowRef(useDataOverlayTool());
+  const measurementAngleTool = shallowRef(useMeasurementAngleTool());
+  const measurementLengthTool = shallowRef(useMeasurementLengthTool());
+  const measurementPolygonTool = shallowRef(useMeasurementPolygonTool());
+  const mcadMoveTool = shallowRef(useMcadMoveTool());
+  const mcadRotateTool = shallowRef(useMcadRotateTool());
+  const mcadScaleTool = shallowRef(useMcadScaleTool());
+  const mcadSelectTool = shallowRef(useMcadSelectTool());
+
+  return {
+    annotationCreateTool,
+    annotationMoveTool,
+    dataOverlayTool,
+    measurementAngleTool,
+    measurementLengthTool,
+    measurementPolygonTool,
+    mcadMoveTool,
+    mcadRotateTool,
+    mcadScaleTool,
+    mcadSelectTool
+  };
+});

package/src/stores/upload.store.ts

@@ -0,0 +1,19 @@
+import { defineStore } from 'pinia';
+import { ref, watch } from 'vue';
+import { Upload } from '@3cr/viewer-types-ts';
+
+export const useUploadStore = defineStore('upload', () => {
+  const showUploads = ref<boolean>(false);
+
+  const uploads = ref<Upload[]>([]);
+
+  watch(
+    uploads,
+    (uploads) => {
+      showUploads.value = uploads.length > 0;
+    },
+    { deep: true }
+  );
+
+  return { uploads, showUploads };
+});

package/src/stores/viewer.store.ts

@@ -0,0 +1,34 @@
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+import { ScanView } from '@3cr/types-ts';
+import { DataOverlay, ViewerOptions } from '@3cr/viewer-types-ts';
+
+export const useViewerStore = defineStore('viewer', () => {
+  const activeView = ref<ScanView>();
+  const enableMouse = ref<boolean>(false);
+  const enableKeyboard = ref<boolean>(false);
+  const inputOverride = ref<boolean>(false);
+  const options = ref<ViewerOptions>({});
+  const version = ref<string>('0.0.0');
+  const notifications = ref<boolean>(false);
+  const measurementToDelete = ref<DataOverlay>();
+  const s_annotationDelete = ref<boolean>(false);
+  const s_measurementDelete = ref<boolean>(false);
+  const m_annotationCreate = ref<boolean>(false);
+  const annotationCreateId = ref<string>('');
+
+  return {
+    activeView,
+    enableMouse,
+    inputOverride,
+    enableKeyboard,
+    options,
+    version,
+    notifications,
+    measurementToDelete,
+    s_annotationDelete,
+    s_measurementDelete,
+    m_annotationCreate,
+    annotationCreateId
+  };
+});

package/src/tools/__tests__/annotation-create.tool.spec.ts

@@ -0,0 +1,90 @@
+import { useViewerStore } from '@/stores/viewer.store';
+import { FrontEndInterfaces, ScanView } from '@3cr/types-ts';
+import { useAnnotationCreateTool } from '@/tools/annotation-create.tool';
+import { Viewer3crServiceImpl } from '@/services/viewer-3cr.service';
+import { flushPromises } from '@vue/test-utils';
+import { storeToRefs } from 'pinia';
+import { useViewer3cr } from '@/composables/useViewer3cr';
+import { MockInstance } from '@vitest/spy';
+
+describe('annotation create tool', () => {
+  const viewer3cr = useViewer3cr() as Viewer3crServiceImpl;
+
+  let activeViewSpy: MockInstance;
+  let create2dSpy: MockInstance;
+
+  beforeEach(() => {
+    const { activeView } = storeToRefs(useViewerStore());
+    activeViewSpy = vi.spyOn(activeView, 'value', 'get').mockReturnValue(ScanView.Sagittal);
+    create2dSpy = vi.spyOn(viewer3cr, 'createAnnotation2dTool');
+  });
+
+  afterEach(() => {
+    activeViewSpy.mockRestore();
+    create2dSpy.mockRestore();
+    vi.clearAllMocks();
+  });
+
+  it('should activate for 2D views', async () => {
+    const annotationCreateTool = useAnnotationCreateTool();
+    annotationCreateTool.isActive.value = true;
+    await flushPromises();
+    expect(create2dSpy).toHaveBeenCalled();
+  });
+
+  it('should not activate for 3D view', async () => {
+    activeViewSpy.mockReset().mockReturnValue(ScanView.Volume);
+    const annotationCreateTool = useAnnotationCreateTool();
+    annotationCreateTool.isActive.value = true;
+    await flushPromises();
+    expect(create2dSpy).not.toHaveBeenCalled();
+  });
+
+  it('should activate and deactivate', async () => {
+    const annotationCreateTool = useAnnotationCreateTool();
+    annotationCreateTool.isActive.value = true;
+    await flushPromises();
+    expect(create2dSpy).toHaveBeenCalledTimes(1);
+    annotationCreateTool.isActive.value = false;
+    await flushPromises();
+    expect(create2dSpy).toHaveBeenCalledTimes(2);
+  });
+
+  it('should activate annotations from 3cr', async () => {
+    const annotationCreateTool = useAnnotationCreateTool();
+    const { annotationCreateId } = storeToRefs(useViewerStore());
+    vi.spyOn(annotationCreateId, 'value', 'get').mockReturnValue('');
+    const createAnnotation3CrSpy = vi.spyOn(viewer3cr, 'createAnnotation2dTool').mockResolvedValue();
+
+    annotationCreateTool.isActive.value = true;
+    await flushPromises();
+
+    await viewer3cr.onPayload({
+      Action: 'mu_01',
+      ReturnChannel: '{}',
+      ReturnTo: '',
+      Message: '',
+      Interface: FrontEndInterfaces.markups
+    });
+    expect(createAnnotation3CrSpy).toHaveBeenCalled();
+    annotationCreateTool.isActive.value = false;
+  });
+
+  it('should not activate annotations from 3cr', async () => {
+    const annotationCreateTool = useAnnotationCreateTool();
+    const { annotationCreateId } = storeToRefs(useViewerStore());
+
+    annotationCreateTool.isActive.value = false;
+    await flushPromises();
+
+    vi.spyOn(annotationCreateId, 'value', 'get').mockReturnValue('123');
+    await viewer3cr.onPayload({
+      Action: 'mu_01',
+      ReturnChannel: '{}',
+      ReturnTo: '',
+      Message: '',
+      Interface: FrontEndInterfaces.markups
+    });
+    expect(create2dSpy).not.toHaveBeenCalled();
+  });
+});

package/src/tools/__tests__/annotation-move.tool.spec.ts

@@ -0,0 +1,107 @@
+import { InteractionType, ScanView } from '@3cr/types-ts';
+import { useAnnotationMoveTool } from '@/tools/annotation-move.tool';
+import { useViewerStore } from '@/stores/viewer.store';
+import { flushPromises } from '@vue/test-utils';
+import { storeToRefs } from 'pinia';
+import { useDataOverlayStore } from '@/stores/data-overlay.store';
+import { DataOverlayDataFaker } from '@test/fakers/data-overlay-data.faker';
+import { DataOverlayAnnotationFaker } from '@test/fakers/data-overlay-annotation.faker';
+import { useViewer3cr } from '@/composables/useViewer3cr';
+import { MockInstance } from '@vitest/spy';
+
+describe('annotation move tool', () => {
+  const viewer3cr = useViewer3cr();
+  const { event } = storeToRefs(useDataOverlayStore());
+
+  let activeViewSpy: MockInstance;
+  let move2dSpy: MockInstance;
+  let move3dSpy: MockInstance;
+
+  beforeEach(() => {
+    const { activeView } = storeToRefs(useViewerStore());
+    activeViewSpy = vi.spyOn(activeView, 'value', 'get').mockReturnValue(ScanView.Sagittal);
+    move2dSpy = vi.spyOn(viewer3cr, 'moveAnnotation2dTool');
+    move3dSpy = vi.spyOn(viewer3cr, 'moveAnnotation3dTool');
+  });
+
+  afterEach(() => {
+    activeViewSpy.mockRestore();
+    move2dSpy.mockRestore();
+    move3dSpy.mockRestore();
+  });
+
+  it('should activate for 2D views', async () => {
+    const annotationMoveTool = useAnnotationMoveTool();
+    annotationMoveTool.isActive.value = true;
+    event.value = DataOverlayDataFaker.annotationEventRaw(InteractionType.POINTER_UP);
+    await flushPromises();
+    expect(move2dSpy).toHaveBeenCalled();
+    expect(move3dSpy).not.toHaveBeenCalled();
+  });
+
+  it('should activate for 3D views', async () => {
+    activeViewSpy.mockReset().mockReturnValue(ScanView.Volume);
+    const annotationMoveTool = useAnnotationMoveTool();
+    annotationMoveTool.isActive.value = true;
+    event.value = DataOverlayDataFaker.annotationEventRaw(InteractionType.POINTER_UP);
+    await flushPromises();
+    expect(move2dSpy).not.toHaveBeenCalled();
+    expect(move3dSpy).toHaveBeenCalled();
+  });
+
+  it('should deactivate move', async () => {
+    const annotationMoveTool = useAnnotationMoveTool();
+
+    annotationMoveTool.isActive.value = true;
+    annotationMoveTool.selected.value = DataOverlayAnnotationFaker.random();
+    await flushPromises();
+
+    annotationMoveTool.isActive.value = false;
+
+    await flushPromises();
+    expect(move2dSpy).toHaveBeenCalled();
+    expect(move3dSpy).toHaveBeenCalled();
+    expect(annotationMoveTool.selected.value).toBeNull();
+  });
+
+  it('should do nothing if not active', async () => {
+    const annotationMoveTool = useAnnotationMoveTool();
+    const dataOverlayStore = useDataOverlayStore();
+
+    annotationMoveTool.isActive.value = false;
+
+    dataOverlayStore.event = DataOverlayDataFaker.annotationEventRaw(InteractionType.POINTER_UP);
+
+    await flushPromises();
+
+    expect(annotationMoveTool.selected.value).toBeNull();
+  });
+  it('should 2d if scanView Saggital', async () => {
+    activeViewSpy.mockReset().mockReturnValue(ScanView.Sagittal);
+    const dataOverlayStore = useDataOverlayStore();
+    const annotationMoveTool = useAnnotationMoveTool();
+
+    annotationMoveTool.isActive.value = true;
+
+    dataOverlayStore.event = DataOverlayDataFaker.annotationEventRaw(InteractionType.POINTER_UP);
+
+    await flushPromises();
+
+    expect(move2dSpy).toHaveBeenCalled();
+    expect(annotationMoveTool.selected.value).toStrictEqual(dataOverlayStore.annotationEvent?.Data.DataOverlay);
+  });
+
+  it('should do nothing if scanView Undefined', async () => {
+    activeViewSpy.mockReset().mockReturnValue(undefined);
+    const dataOverlayStore = useDataOverlayStore();
+    const annotationMoveTool = useAnnotationMoveTool();
+
+    annotationMoveTool.isActive.value = true;
+
+    dataOverlayStore.event = DataOverlayDataFaker.annotationEventRaw(InteractionType.POINTER_UP);
+
+    await flushPromises();
+
+    expect(move2dSpy).not.toHaveBeenCalled();
+  });
+});

package/src/tools/__tests__/data-overlay.tool.spec.ts

@@ -0,0 +1,127 @@
+import { storeToRefs } from 'pinia';
+import { useDataOverlayStore } from '@/stores/data-overlay.store';
+import { useDataOverlayTool } from '@/tools/data-overlay.tool';
+import { DOMWrapper, flushPromises } from '@vue/test-utils';
+import { DataOverlayDataFaker } from '@test/fakers/data-overlay-data.faker';
+import { InteractionType } from '@3cr/types-ts';
+import { useMcadStore } from '@/stores/mcad.store';
+import { McadObjectInteractionFaker } from '@test/fakers/mcad-object-interaction.faker';
+
+describe('data overlay tool', () => {
+  const { event: dataOverlayEvent } = storeToRefs(useDataOverlayStore());
+  const { event: mcadEvent } = storeToRefs(useMcadStore());
+
+  it('should capture annotation events', async () => {
+    const dataOverlayTool = useDataOverlayTool();
+    dataOverlayTool.isActive.value = true;
+    await flushPromises();
+
+    dataOverlayEvent.value = DataOverlayDataFaker.annotationEventRaw(InteractionType.HOVER_START);
+    const wrapper = new DOMWrapper(document.body);
+    await wrapper.trigger('mousedown');
+    await wrapper.trigger('mouseup');
+
+    expect(dataOverlayTool.selected.value).not.toBe(null);
+  });
+
+  it('should capture measurement events', async () => {
+    const dataOverlayTool = useDataOverlayTool();
+    dataOverlayTool.isActive.value = true;
+    await flushPromises();
+
+    dataOverlayEvent.value = DataOverlayDataFaker.lengthEventRaw(InteractionType.HOVER_START);
+    const wrapper = new DOMWrapper(document.body);
+    await wrapper.trigger('mousedown');
+    await wrapper.trigger('mouseup');
+
+    expect(dataOverlayTool.selected.value).not.toBe(null);
+  });
+
+  it('should capture mcad events', async () => {
+    const dataOverlayTool = useDataOverlayTool();
+    dataOverlayTool.isActive.value = true;
+    await flushPromises();
+
+    mcadEvent.value = McadObjectInteractionFaker.randomRaw(InteractionType.HOVER_START);
+    const wrapper = new DOMWrapper(document.body);
+    await wrapper.trigger('mousedown');
+    await wrapper.trigger('mouseup');
+
+    expect(dataOverlayTool.selected.value).not.toBe(null);
+  });
+
+  it('should ignore event on mouse move', async () => {
+    const dataOverlayTool = useDataOverlayTool();
+    dataOverlayTool.isActive.value = true;
+    await flushPromises();
+
+    dataOverlayEvent.value = DataOverlayDataFaker.annotationEventRaw(InteractionType.HOVER_START);
+    const wrapper = new DOMWrapper(document.body);
+    await wrapper.trigger('mousedown');
+    await wrapper.trigger('mousemove');
+    await wrapper.trigger('mouseup');
+
+    expect(dataOverlayTool.selected.value).toBe(null);
+  });
+
+  it('should ignore event mousedown', async () => {
+    const dataOverlayTool = useDataOverlayTool();
+    dataOverlayTool.isActive.value = false;
+    await flushPromises();
+
+    dataOverlayEvent.value = DataOverlayDataFaker.annotationEventRaw(InteractionType.HOVER_START);
+    const wrapper = new DOMWrapper(document.body);
+    await wrapper.trigger('mousedown');
+
+    expect(dataOverlayTool.selected.value).toBe(null);
+  });
+
+  it('should ignore event mouseMove', async () => {
+    const dataOverlayTool = useDataOverlayTool();
+    dataOverlayTool.isActive.value = false;
+    await flushPromises();
+
+    dataOverlayEvent.value = DataOverlayDataFaker.annotationEventRaw(InteractionType.HOVER_START);
+    const wrapper = new DOMWrapper(document.body);
+    await wrapper.trigger('mousemove');
+
+    expect(dataOverlayTool.selected.value).toBe(null);
+  });
+
+  it('should defocus onInteraction on hover end', async () => {
+    const dataOverlayTool = useDataOverlayTool();
+    dataOverlayTool.isActive.value = true;
+    await flushPromises();
+
+    dataOverlayEvent.value = DataOverlayDataFaker.annotationEventRaw(InteractionType.HOVER_END);
+    const wrapper = new DOMWrapper(document.body);
+    await wrapper.trigger('mousemove');
+
+    expect(dataOverlayTool.selected.value).toBe(null);
+  });
+
+  it('should defocus mcad onInteraction on hover end', async () => {
+    const dataOverlayTool = useDataOverlayTool();
+    dataOverlayTool.isActive.value = true;
+    await flushPromises();
+
+    mcadEvent.value = McadObjectInteractionFaker.randomRaw(InteractionType.HOVER_END);
+    const wrapper = new DOMWrapper(document.body);
+    await wrapper.trigger('mousedown');
+    await wrapper.trigger('mouseup');
+
+    expect(dataOverlayTool.selected.value).toBe(null);
+  });
+  it('should defocus mcad onInteraction on none', async () => {
+    const dataOverlayTool = useDataOverlayTool();
+    dataOverlayTool.isActive.value = true;
+    await flushPromises();
+
+    mcadEvent.value = McadObjectInteractionFaker.randomRaw(InteractionType.NONE);
+    const wrapper = new DOMWrapper(document.body);
+    await wrapper.trigger('mousedown');
+    await wrapper.trigger('mouseup');
+
+    expect(dataOverlayTool.selected.value).toBe(null);
+  });
+});

package/src/tools/__tests__/mcad-move.tool.spec.ts

@@ -0,0 +1,106 @@
+import { MockInstance } from '@vitest/spy';
+import { storeToRefs } from 'pinia';
+import { useMcadStore } from '@/stores/mcad.store';
+import { useMcadMoveTool } from '@/tools/mcad-move.tool';
+import { McadObjectInteractionFaker } from '@test/fakers/mcad-object-interaction.faker';
+import { InteractionType } from '@3cr/types-ts';
+import { flushPromises } from '@vue/test-utils';
+import { DataOverlayMcadFaker } from '@test/fakers/data-overlay-mcad.faker';
+import { useViewer3cr } from '@/composables/useViewer3cr';
+
+describe('mcad move tool', () => {
+  const viewer3cr = useViewer3cr();
+
+  const { event: mcadEvent } = storeToRefs(useMcadStore());
+  let moveSpy: MockInstance;
+
+  beforeEach(() => {
+    moveSpy = vi.spyOn(viewer3cr, 'moveMcadObject');
+  });
+
+  afterEach(() => {
+    moveSpy.mockRestore();
+  });
+
+  it('should move via 3cr event', async () => {
+    const mcadMoveTool = useMcadMoveTool();
+    mcadMoveTool.isActive.value = true;
+    mcadEvent.value = McadObjectInteractionFaker.randomRaw(InteractionType.POINTER_UP);
+    await flushPromises();
+
+    expect(moveSpy).toHaveBeenCalled();
+    expect(mcadMoveTool.selected.value).not.toBe(null);
+  });
+
+  it('should not move via 3cr event', async () => {
+    const mcadMoveTool = useMcadMoveTool();
+    mcadMoveTool.isActive.value = true;
+    mcadEvent.value = McadObjectInteractionFaker.randomRaw(InteractionType.NONE);
+    await flushPromises();
+
+    expect(moveSpy).not.toHaveBeenCalled();
+    expect(mcadMoveTool.selected.value).toBe(null);
+  });
+
+  it('should move programmatically', async () => {
+    const mcadMoveTool = useMcadMoveTool();
+    mcadMoveTool.isActive.value = true;
+    mcadMoveTool.selected.value = DataOverlayMcadFaker.random();
+    await flushPromises();
+
+    expect(moveSpy).toHaveBeenCalled();
+  });
+
+  it('should deactivate move', async () => {
+    const mcadMoveTool = useMcadMoveTool();
+
+    mcadMoveTool.isActive.value = true;
+    mcadMoveTool.selected.value = DataOverlayMcadFaker.random();
+    await flushPromises();
+
+    mcadMoveTool.isActive.value = false;
+
+    await flushPromises();
+    expect(moveSpy).toHaveBeenCalled();
+    expect(mcadMoveTool.selected.value).toBeNull();
+  });
+  it('should do next prev', async () => {
+    const mcadMoveTool = useMcadMoveTool();
+    mcadMoveTool.isActive.value = true;
+
+    mcadMoveTool.selected.value = DataOverlayMcadFaker.random();
+    await flushPromises();
+    expect(moveSpy).toHaveBeenCalledTimes(1);
+
+    mcadMoveTool.selected.value = null;
+    await flushPromises();
+    expect(moveSpy).toHaveBeenCalledTimes(2);
+  });
+  it('should not do next prev', async () => {
+    const mcadMoveTool = useMcadMoveTool();
+    mcadMoveTool.isActive.value = true;
+
+    mcadMoveTool.selected.value = DataOverlayMcadFaker.random();
+    await flushPromises();
+    expect(moveSpy).toHaveBeenCalledTimes(1);
+
+    mcadMoveTool.selected.value = null;
+    await flushPromises();
+    expect(moveSpy).toHaveBeenCalledTimes(2);
+  });
+  it('should not do next prev', async () => {
+    const mcadMoveTool = useMcadMoveTool();
+    mcadMoveTool.isActive.value = true;
+    const set = DataOverlayMcadFaker.random();
+    const set2 = DataOverlayMcadFaker.random();
+
+    set2.Id = set.Id;
+    mcadMoveTool.selected.value = set;
+    await flushPromises();
+    expect(moveSpy).toHaveBeenCalledTimes(1);
+
+    mcadMoveTool.selected.value = set2;
+    await flushPromises();
+    expect(moveSpy).toHaveBeenCalledTimes(1);
+  });
+});

package/src/tools/__tests__/mcad-rotate.tool.spec.ts

@@ -0,0 +1,103 @@
+import { storeToRefs } from 'pinia';
+import { useMcadStore } from '@/stores/mcad.store';
+import { McadObjectInteractionFaker } from '@test/fakers/mcad-object-interaction.faker';
+import { InteractionType } from '@3cr/types-ts';
+import { flushPromises } from '@vue/test-utils';
+import { DataOverlayMcadFaker } from '@test/fakers/data-overlay-mcad.faker';
+import { useMcadRotateTool } from '@/tools/mcad-rotate.tool';
+import { useViewer3cr } from '@/composables/useViewer3cr';
+import { MockInstance } from '@vitest/spy';
+
+describe('mcad rotate tool', () => {
+  const viewer3cr = useViewer3cr();
+  const { event: mcadEvent } = storeToRefs(useMcadStore());
+
+  let rotateSpy: MockInstance;
+
+  beforeEach(() => {
+    rotateSpy = vi.spyOn(viewer3cr, 'rotateMcadObject');
+  });
+
+  afterEach(() => {
+    rotateSpy.mockRestore();
+  });
+
+  it('should rotate via 3cr event', async () => {
+    const mcadRotateTool = useMcadRotateTool();
+    mcadRotateTool.isActive.value = true;
+    mcadEvent.value = McadObjectInteractionFaker.randomRaw(InteractionType.POINTER_UP);
+    await flushPromises();
+
+    expect(rotateSpy).toHaveBeenCalled();
+    expect(mcadRotateTool.selected.value).not.toBe(null);
+  });
+
+  it('should not rotate via 3cr event', async () => {
+    const mcadRotateTool = useMcadRotateTool();
+    mcadRotateTool.isActive.value = true;
+    mcadEvent.value = McadObjectInteractionFaker.randomRaw(InteractionType.NONE);
+    await flushPromises();
+
+    expect(rotateSpy).not.toHaveBeenCalled();
+    expect(mcadRotateTool.selected.value).toBe(null);
+  });
+
+  it('should rotate programmatically', async () => {
+    const mcadRotateTool = useMcadRotateTool();
+    mcadRotateTool.isActive.value = true;
+    mcadRotateTool.selected.value = DataOverlayMcadFaker.random();
+    await flushPromises();
+
+    expect(rotateSpy).toHaveBeenCalled();
+  });
+
+  it('should deactivate move', async () => {
+    const mcadRotateTool = useMcadRotateTool();
+
+    mcadRotateTool.isActive.value = true;
+    await flushPromises();
+    mcadRotateTool.isActive.value = false;
+    mcadRotateTool.selected.value = DataOverlayMcadFaker.random();
+    await flushPromises();
+
+    expect(rotateSpy).toHaveBeenCalled();
+  });
+  it('should deactivate move', async () => {
+    const mcadRotateTool = useMcadRotateTool();
+
+    mcadRotateTool.isActive.value = true;
+    await flushPromises();
+    mcadRotateTool.isActive.value = false;
+    mcadRotateTool.selected.value = null;
+    await flushPromises();
+
+    expect(rotateSpy).not.toHaveBeenCalled();
+  });
+  it('should do next prev', async () => {
+    const mcadRotateTool = useMcadRotateTool();
+    mcadRotateTool.isActive.value = true;
+
+    mcadRotateTool.selected.value = DataOverlayMcadFaker.random();
+    await flushPromises();
+    expect(rotateSpy).toHaveBeenCalledTimes(1);
+
+    mcadRotateTool.selected.value = null;
+    await flushPromises();
+    expect(rotateSpy).toHaveBeenCalledTimes(2);
+  });
+  it('should not do next prev', async () => {
+    const mcadRotateTool = useMcadRotateTool();
+    mcadRotateTool.isActive.value = true;
+    const set = DataOverlayMcadFaker.random();
+    const set2 = DataOverlayMcadFaker.random();
+
+    set2.Id = set.Id;
+    mcadRotateTool.selected.value = set;
+    await flushPromises();
+    expect(rotateSpy).toHaveBeenCalledTimes(1);
+
+    mcadRotateTool.selected.value = set2;
+    await flushPromises();
+    expect(rotateSpy).toHaveBeenCalledTimes(1);
+  });
+});

package/src/tools/__tests__/mcad-scale.tool.spec.ts

@@ -0,0 +1,8 @@
+import { useMcadScaleTool } from '@/tools/mcad-scale-tool';
+
+describe('mcad scale tool', () => {
+  it('should instantiate', () => {
+    const mcadScaleTool = useMcadScaleTool();
+    expect(mcadScaleTool).toBeTruthy();
+  });
+});