@3cr/viewer-browser 0.0.247 → 0.0.292

package/src/composables/useMedia.ts

@@ -0,0 +1,27 @@
+import { ref, watchEffect } from 'vue';
+
+export function useMedia(query: string) {
+  const matches = ref<boolean>(false);
+
+  watchEffect((onInvalidate) => {
+    const media = window.matchMedia(query);
+
+    if (media.matches !== matches.value) {
+      matches.value = media.matches;
+    }
+
+    /* v8 ignore start -- @preserve */
+    const onChange = () => {
+      matches.value = media.matches;
+    };
+
+    media.addEventListener('change', onChange);
+
+    onInvalidate(() => {
+      media.removeEventListener('change', onChange);
+    });
+    /* v8 ignore stop -- @preserve */
+  });
+
+  return matches;
+}

package/src/composables/useNavigationCube.ts

@@ -0,0 +1,80 @@
+import { fullscreenView, isFullscreen, isLayout1x3, isLayout2x2 } from '@/models/scanState';
+import { AnchorPoint, InteractivityState, NavigationCubeTransform, ScanView } from '@3cr/types-ts';
+import { useViewer3cr } from '@/composables/useViewer3cr';
+import { watch, ref, MaybeRef, computed } from 'vue';
+import { useBoundingBox } from '@/composables/useBoundingBox';
+
+// TODO: possible move to store?
+export const isVisible = ref<boolean>(true);
+export const navCubeBoundingBox = ref({ x: 0, y: 0, width: 0, height: 0 });
+
+export function useNavigationCube(canvas: MaybeRef<HTMLCanvasElement | null | undefined>) {
+  const viewer3cr = useViewer3cr();
+  const { width: cwidth, height: cheight } = useBoundingBox(canvas);
+
+  const canvasWidth = computed(() => cwidth.value * window.devicePixelRatio);
+  const canvasHeight = computed(() => cheight.value * window.devicePixelRatio);
+
+  watch([isVisible, isFullscreen, fullscreenView], async ([isVisible, isFullscreen, fullscreenView]) => {
+    if (!isFullscreen || fullscreenView === ScanView.Volume) {
+      const message: InteractivityState = { Version: '0.0.0', Value: isVisible };
+      await viewer3cr.setNavCubeVisibility({ message });
+    } else {
+      // Disable navigation cube when fullscreen on a 2D view
+      const message: InteractivityState = { Version: '0.0.0', Value: false };
+      await viewer3cr.setNavCubeVisibility({ message });
+    }
+  });
+
+  watch(navCubeBoundingBox, async (boundingBox) => {
+    const message: NavigationCubeTransform = {
+      Version: '0.0.0',
+      AnchorPoint: AnchorPoint.TOP_LEFT,
+      Position: { Version: '0.0.0', X: boundingBox.x, Y: boundingBox.y },
+      Size: { Version: '0.0.0', X: boundingBox.width, Y: boundingBox.height }
+    };
+    await viewer3cr.setNavCubePositionSize({ message });
+  });
+
+  watch(
+    [isFullscreen, canvasWidth, canvasHeight],
+    ([isFullscreen, canvasWidth, canvasHeight]) => {
+      if (isFullscreen) {
+        const width = canvasWidth * 0.1;
+        const height = canvasWidth * 0.1; // Proportional to width so cube is always square
+        const x = canvasWidth - width;
+        const y = canvasHeight - height;
+        navCubeBoundingBox.value = { x, y, width, height };
+      }
+    },
+    { immediate: true }
+  );
+
+  watch(
+    [isLayout2x2, isFullscreen, canvasWidth, canvasHeight],
+    ([isLayout2x2, isFullscreen, canvasWidth, canvasHeight]) => {
+      if (isLayout2x2 && !isFullscreen) {
+        const width = canvasWidth * 0.1;
+        const height = canvasWidth * 0.1; // Proportional to width so cube is always square
+        const x = Math.floor(canvasWidth / 2 - width);
+        const y = Math.floor(canvasHeight / 2 - height);
+        navCubeBoundingBox.value = { x, y, width, height };
+      }
+    },
+    { immediate: true }
+  );
+
+  watch(
+    [isLayout1x3, isFullscreen, canvasWidth, canvasHeight],
+    ([isLayout1x3, isFullscreen, canvasWidth, canvasHeight]) => {
+      if (isLayout1x3 && !isFullscreen) {
+        const width = canvasWidth * 0.1;
+        const height = canvasWidth * 0.1; // Proportional to width so cube is always square
+        const x = Math.floor(canvasWidth - canvasHeight / 3 - width);
+        const y = canvasHeight - height;
+        navCubeBoundingBox.value = { x, y, width, height };
+      }
+    },
+    { immediate: true }
+  );
+}

package/src/composables/useNotificationHandler.ts

@@ -0,0 +1,82 @@
+import { useNotification } from '@kyvg/vue3-notification';
+import { useI18n } from 'vue-i18n';
+import { InteractivityActions, NavigationCubeActions, NotificationPayload, NotificationsActions } from '@3cr/types-ts';
+import { t as t3 } from '@3cr/translations-ts';
+
+type NotificationType = 'success' | 'info' | 'warn' | 'error';
+
+export function useNotificationHandler() {
+  const { t } = useI18n();
+  const { notify } = useNotification();
+
+  function getNotificationText(notification: NotificationPayload): string {
+    return t3(notification.Code, {});
+  }
+
+  function getNotificationTitle(action: NotificationsActions): string {
+    switch (action) {
+      case NotificationsActions.no01:
+        return t('enums.notificationType.success');
+      case NotificationsActions.no02:
+        return t('enums.notificationType.error');
+      case NotificationsActions.no03:
+        return t('enums.notificationType.warning');
+      default:
+      case NotificationsActions.no04:
+        return t('enums.notificationType.info');
+    }
+  }
+
+  function getNotificationType(action: NotificationsActions): NotificationType {
+    switch (action) {
+      case NotificationsActions.no01:
+        return 'success';
+      case NotificationsActions.no02:
+        return 'error';
+      case NotificationsActions.no03:
+        return 'warn';
+      default:
+      case NotificationsActions.no04:
+        return 'info';
+    }
+  }
+
+  function shouldDisplayNotification(action: NotificationsActions, notification: NotificationPayload): boolean {
+    // Hide type specific messages
+    const hiddenTypes = [NotificationsActions.no01, NotificationsActions.no04];
+    if (hiddenTypes.includes(action)) {
+      return false;
+    }
+
+    // Hide all slider actions
+    if (notification.Action.startsWith('sl')) {
+      return false;
+    }
+
+    // Hide action specific messages
+    const hiddenActions = [
+      InteractivityActions.in01,
+      InteractivityActions.in02,
+      InteractivityActions.in03,
+      InteractivityActions.in04,
+      NavigationCubeActions.nc01
+    ] as string[];
+
+    return !hiddenActions.includes(notification.Action);
+  }
+
+  async function handler(action: NotificationsActions, message: string) {
+    const notification = JSON.parse(message) as NotificationPayload;
+    if (shouldDisplayNotification(action, notification)) {
+      await announce(action, notification);
+    }
+  }
+  async function announce(action: NotificationsActions, notification: NotificationPayload) {
+    const title = getNotificationTitle(action);
+    const text = getNotificationText(notification);
+    const type = getNotificationType(action);
+    notify({ title, text, type });
+  }
+
+  return { handler, announce };
+}

package/src/composables/useResizeObserver.ts

@@ -0,0 +1,31 @@
+import { MaybeRef, onBeforeUnmount, unref, watch } from 'vue';
+
+export type ResizeCallback = (entries: ResizeObserverEntry[]) => void;
+
+/**
+ * Observes resize events for elements.
+ * @param element The element to observe.
+ * @param callback The resize callback.
+ */
+export function useResizeObserver(element: MaybeRef<Element | null | undefined>, callback: ResizeCallback) {
+  const observer = new ResizeObserver(callback);
+
+  onBeforeUnmount(() => {
+    observer?.disconnect();
+  });
+
+  watch(
+    () => unref(element),
+    (next, prev) => {
+      /* v8 ignore start -- @preserve */
+      if (prev instanceof Element) {
+        observer?.unobserve(prev);
+      }
+      if (next instanceof Element) {
+        observer?.observe(next);
+      }
+      /* v8 ignore stop -- @preserve */
+    },
+    { immediate: true }
+  );
+}

package/src/composables/useToolGroup.ts

@@ -0,0 +1,36 @@
+import { ViewerTool } from '@/types/viewer-tool';
+import { computed } from 'vue';
+
+type Tool<T extends ViewerTool[]> = T extends ViewerTool[] ? T[number] : never;
+
+/**
+ * Create a tool group where only one tool can be active at a time.
+ * @param tools The tools.
+ */
+export function useToolGroup<T extends ViewerTool[]>(...tools: T) {
+  const activeTool = computed({
+    get(): Tool<T> | null {
+      const idx = tools.findIndex((tool) => tool.isActive.value);
+      return idx !== -1 ? (tools[idx] as Tool<T>) : null;
+    },
+    set(tool: Tool<T> | null): void {
+      const prev = tools.find((t) => t.isActive.value);
+      if (prev) prev.isActive.value = false;
+      const next = tools.find((t) => t === tool);
+      if (next) next.isActive.value = true;
+    }
+  });
+
+  const activeIndex = computed(() => {
+    const idx = tools.findIndex((tool) => tool.isActive.value);
+    return idx !== -1 ? idx : null;
+  });
+
+  function toggleTool(tool: Tool<T>): boolean {
+    const state = activeTool.value !== tool;
+    activeTool.value = state ? tool : null;
+    return state;
+  }
+
+  return { activeTool, activeIndex, toggleTool };
+}

package/src/composables/useViewName.ts

@@ -0,0 +1,34 @@
+import { ScanView } from '@3cr/types-ts';
+import { MaybeRef, ref, unref, watch } from 'vue';
+import { useI18n } from 'vue-i18n';
+
+export function useViewName(view: MaybeRef<ScanView>) {
+  const { t } = useI18n();
+
+  const name = ref<string>();
+
+  function getViewName(view: ScanView): string {
+    switch (view) {
+      case ScanView.Volume:
+        return t('enums.scanView.volume');
+      case ScanView.Transverse:
+        return t('enums.scanView.transverse');
+      case ScanView.Sagittal:
+        return t('enums.scanView.sagittal');
+      case ScanView.Coronal:
+        return t('enums.scanView.coronal');
+      default:
+        return '';
+    }
+  }
+
+  watch(
+    () => unref(view),
+    (value: ScanView) => {
+      name.value = getViewName(value);
+    },
+    { immediate: true }
+  );
+
+  return { name };
+}

package/src/composables/useViewer3cr.ts

@@ -1,6 +1,7 @@
-import { Viewer3crService } from '@/services/viewer-3cr.service';
+import { Viewer3crServiceImpl } from '@/services/viewer-3cr.service';
+import { Viewer3crService } from '@3cr/viewer-types-ts';
 
-const viewer3cr = new Viewer3crService();
+const viewer3cr = new Viewer3crServiceImpl();
 
 export function useViewer3cr(): Viewer3crService {
   return viewer3cr;

package/src/config.ts

@@ -1 +1 @@
-export const injectedStyleId = "__3cr-viewer-injected-style__";
+export const injectedStyleId = '__3cr-viewer-injected-style__';

package/src/constants.ts

@@ -0,0 +1,8 @@
+export const PRICING_URL = 'https://3dicomviewer.com/pricing';
+
+export const SUPPORT_URL = 'https://3dicomviewer.com/contact-3dicom';
+
+export const DEMO_BUCKET_URL = 'https://webgl-3dr.singular.health/demo';
+
+export const EMAIL_REGEX =
+  /^(([^<>()[\]\\.,;:\s@']+(\.[^<>()\\[\]\\.,;:\s@']+)*)|('.+'))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;

package/src/functions/HotkeyScope.ts

@@ -0,0 +1,87 @@
+import hotkeys, { HotkeysEvent } from 'hotkeys-js';
+import { isMac } from '@/functions/platform';
+import { MaybePromise } from 'rollup';
+
+export enum HotkeyScope {
+  MCAD_MENU = 'mcad_menu',
+  PRIMARY = 'primary',
+  MEASUREMENT_MENU = 'measurement_menu',
+  ANNOTATION_MENU = 'annotation_menu',
+  ANNOTATION_TOOLS = 'annotation_tools',
+  MEASUREMENT_TOOLS = 'measurement_tools'
+  // NAVIGATION_DRAWER = 'navigation_drawer'
+}
+
+// Always Windows keys. Mac keys will be generated at runtime.
+export enum Hotkeys {
+  CTRL_SHIFT_A = 'ctrl+shift+a',
+  CTRL_SHIFT_C = 'ctrl+shift+c',
+  CTRL_SHIFT_D = 'ctrl+shift+d',
+  CTRL_SHIFT_DEL = 'ctrl+shift+del',
+  CTRL_SHIFT_E = 'ctrl+shift+e',
+  CTRL_SHIFT_F = 'ctrl+shift+f',
+  CTRL_SHIFT_G = 'ctrl+shift+g',
+  CTRL_SHIFT_H = 'ctrl+shift+h',
+  CTRL_SHIFT_L = 'ctrl+shift+l',
+  CTRL_SHIFT_M = 'ctrl+shift+m',
+  CTRL_SHIFT_P = 'ctrl+shift+p',
+  CTRL_SHIFT_Q = 'ctrl+shift+q',
+  CTRL_SHIFT_R = 'ctrl+shift+r',
+  CTRL_SHIFT_S = 'ctrl+shift+s',
+  CTRL_SHIFT_V = 'ctrl+shift+v',
+  CTRL_SHIFT_PLUS = 'ctrl+shift++',
+  CTRL_SHIFT_MINUS = 'ctrl+shift+-',
+  CTRL_SHIFT_SPACE = 'ctrl+shift+space',
+  ALT_A = 'alt+a',
+  ALT_H = 'alt+h',
+  ALT_D = 'alt+d',
+  ALT_M = 'alt+m',
+  ALT_E = 'alt+e',
+  ALT_F = 'alt+f'
+}
+
+function generateHotkey(...params: Array<string[]>) {
+  return params.map(String).join(',');
+}
+
+type HotkeyDefinition = {
+  [key in Hotkeys]?: (event: any, handler: any) => MaybePromise<void>;
+};
+
+// Vitest not liking us testing defaultfunctions with object modifiers
+/* v8 ignore start -- @preserve */
+export function defineHotkeys(scope: HotkeyScope, definition: HotkeyDefinition) {
+  const keys = transformHotkeysMac(Object.values(Object.keys(definition)));
+  hotkeys(generateHotkey(keys), scope, (event: KeyboardEvent, handler: HotkeysEvent) =>
+    hotKeyHandler(definition, event, handler)
+  );
+  hotkeys.setScope(scope);
+}
+/* v8 ignore stop -- @preserve */
+
+export function defaultHotkeys(definition: HotkeyDefinition) {
+  const keys = transformHotkeysMac(Object.values(Object.keys(definition)));
+  hotkeys(generateHotkey(keys), (event: KeyboardEvent, handler: HotkeysEvent) =>
+    hotKeyHandler(definition, event, handler)
+  );
+}
+
+function hotKeyHandler(definition: HotkeyDefinition, event: KeyboardEvent, handler: HotkeysEvent) {
+  event.preventDefault();
+  const key = handler.key as Hotkeys;
+  const method = definition[key.replace('command', 'ctrl').replace('option', 'alt') as Hotkeys];
+  if (method) {
+    method(event, handler);
+  }
+}
+export function resetScope(scope: HotkeyScope) {
+  hotkeys.deleteScope(scope);
+  hotkeys.setScope(HotkeyScope.PRIMARY);
+}
+
+/* v8 ignore start -- @preserve */
+function transformHotkeysMac(keys: string[]): string[] {
+  if (isMac()) return keys.map((key) => key.replace('ctrl', 'command').replace('alt', 'option'));
+  return keys;
+}
+/* v8 ignore stop -- @preserve */

package/src/functions/__tests__/HotkeyScope.spec.ts

@@ -0,0 +1,49 @@
+import { MockImportOriginal } from '@test/MockImportOriginal';
+import { defaultHotkeys, Hotkeys, HotkeyScope, resetScope } from '@/functions/HotkeyScope';
+import hotkeys from 'hotkeys-js';
+import { flushPromises } from '@vue/test-utils';
+
+vi.mock('hotkeys-js', async (importOriginal: MockImportOriginal<typeof import('hotkeys-js')>) => {
+  return {
+    ...(await importOriginal()),
+    default: vi.fn().mockReturnValue({
+      setScope: vi.fn(),
+      deleteScope: vi.fn()
+    })
+  };
+});
+describe('HotkeyScope tests', () => {
+  it('should map defaultHotkeys', async () => {
+    const altD = vi.fn();
+    const hotkeysMocked = vi.mocked(hotkeys);
+    hotkeysMocked.mockImplementationOnce((params: any, params2: any) => {
+      params2({ preventDefault: vi.fn() }, { key: params });
+    });
+    defaultHotkeys({
+      [Hotkeys.ALT_D]: altD
+    });
+
+    await flushPromises();
+    expect(altD).toHaveBeenCalled();
+  });
+
+  it('should resetScope', async () => {
+    const setScope = vi.fn();
+    const deleteScope = vi.fn();
+    Object.defineProperty(hotkeys, 'setScope', {
+      value: setScope,
+      writable: true // possibility to override
+    });
+    Object.defineProperty(hotkeys, 'deleteScope', {
+      value: deleteScope,
+      writable: true // possibility to override
+    });
+
+    await flushPromises();
+    resetScope(HotkeyScope.MCAD_MENU);
+
+    await flushPromises();
+    expect(setScope).toHaveBeenCalled();
+    expect(deleteScope).toHaveBeenCalled();
+  });
+});

package/src/functions/__tests__/colours.spec.ts

@@ -0,0 +1,42 @@
+import { fromColourData, hexToRgb, hexToRgba, rgbaToHex, rgbToHex, toColourData } from '@/functions/colours';
+import { ColourData } from '@3cr/types-ts/types/ColourData';
+
+describe('colour tests', () => {
+  it('should convert RGB to hex', () => {
+    const hex = rgbToHex(255, 0, 255);
+    expect(hex).toBe('#ff00ff');
+  });
+
+  it('should convert RGBA to hex', () => {
+    const hex = rgbaToHex(255, 0, 255, 16);
+    expect(hex).toBe('#ff00ff10');
+  });
+
+  it('should convert hex to RGB', () => {
+    const [r, g, b] = hexToRgb('#fa4b8c');
+    expect(r).toBe(250);
+    expect(g).toBe(75);
+    expect(b).toBe(140);
+  });
+
+  it('should convert hex to RGBA', () => {
+    const [r, g, b, a] = hexToRgba('#1c7a4ff9');
+    expect(r).toBe(28);
+    expect(g).toBe(122);
+    expect(b).toBe(79);
+    expect(a).toBe(249);
+  });
+
+  it('should convert from colour data', () => {
+    const data: ColourData = { Version: '0.0.0', R: 0.1, G: 0.2, B: 0.3, A: 1 };
+    const hex = fromColourData(data);
+    expect(hex).toBe('#19334c');
+  });
+
+  it('should convert to colour data', () => {
+    const { R, G, B } = toColourData('#9f6a4d');
+    expect(R).toBeCloseTo(0.62);
+    expect(G).toBeCloseTo(0.42);
+    expect(B).toBeCloseTo(0.3);
+  });
+});

package/src/functions/__tests__/fileReader.spec.ts

@@ -0,0 +1,130 @@
+import { OnFileCallback, traverseDirectoryTreeWrapper } from '@/functions/fileReader';
+
+describe('fileReader', () => {
+  it('should process a single file', async () => {
+    const mockFileCallback: OnFileCallback = vi.fn();
+    const mockFile = new File(['content'], 'mockFile.txt', { type: 'text/plain' });
+
+    // Mock FileSystemFileEntry
+    const mockFileEntry = {
+      isFile: true,
+      isDirectory: false,
+      file: vi.fn((callback: (file: File) => void) => callback(mockFile))
+    } as unknown as FileSystemFileEntry;
+
+    // Mock DataTransferItem
+    const mockEntry = {
+      webkitGetAsEntry: vi.fn(() => mockFileEntry)
+    } as unknown as DataTransferItem;
+
+    // Mock DataTransferItemList
+    const mockDataTransferItemList = [mockEntry] as unknown as DataTransferItemList;
+
+    // Call the wrapper function
+    await traverseDirectoryTreeWrapper(mockDataTransferItemList, mockFileCallback);
+
+    // Assertions
+    expect(mockFileCallback).toHaveBeenCalledWith(mockFile, '');
+    expect(mockFileCallback).toHaveBeenCalledTimes(1);
+  });
+
+  it('should process a nested directory with files', async () => {
+    const mockFileCallback: OnFileCallback = vi.fn();
+    const mockFile = new File(['content'], 'nestedFile.txt', { type: 'text/plain' });
+
+    // Mock FileSystemFileEntry
+    const mockFileEntry = {
+      isFile: true,
+      isDirectory: false,
+      file: vi.fn((callback: (file: File) => void) => callback(mockFile))
+    } as unknown as FileSystemFileEntry;
+
+    // Mock nested FileSystemDirectoryReader
+    const mockNestedDirectoryReader = {
+      readEntries: vi
+        .fn()
+        .mockImplementationOnce((success: (entries: Array<FileSystemEntry>) => void) => {
+          success([mockFileEntry]); // First call returns the file entry
+        })
+        .mockImplementationOnce((success: (entries: Array<FileSystemEntry>) => void) => {
+          success([]); // Second call returns no entries, ending recursion
+        })
+    } as unknown as FileSystemDirectoryReader;
+
+    // Mock nested FileSystemDirectoryEntry
+    const mockNestedDirectoryEntry = {
+      isFile: false,
+      isDirectory: true,
+      name: 'nestedDirectory',
+      createReader: vi.fn(() => mockNestedDirectoryReader)
+    } as unknown as FileSystemDirectoryEntry;
+
+    // Mock top-level FileSystemDirectoryReader
+    const mockDirectoryReader = {
+      readEntries: vi
+        .fn()
+        .mockImplementationOnce((success: (entries: Array<FileSystemEntry>) => void) => {
+          success([mockNestedDirectoryEntry]); // First call returns the nested directory
+        })
+        .mockImplementationOnce((success: (entries: Array<FileSystemEntry>) => void) => {
+          success([]); // Second call returns no entries, ending recursion
+        })
+    } as unknown as FileSystemDirectoryReader;
+
+    // Mock top-level FileSystemDirectoryEntry
+    const mockDirectoryEntry = {
+      isFile: false,
+      isDirectory: true,
+      name: 'mockDirectory',
+      createReader: vi.fn(() => mockDirectoryReader)
+    } as unknown as FileSystemDirectoryEntry;
+
+    // Mock DataTransferItem
+    const mockEntry = {
+      webkitGetAsEntry: vi.fn(() => mockDirectoryEntry)
+    } as unknown as DataTransferItem;
+
+    // Mock DataTransferItemList
+    const mockDataTransferItemList = [mockEntry] as unknown as DataTransferItemList;
+
+    // Call the wrapper function
+    await traverseDirectoryTreeWrapper(mockDataTransferItemList, mockFileCallback);
+
+    // Assertions
+    expect(mockFileCallback).toHaveBeenCalledWith(mockFile, 'mockDirectory/nestedDirectory/');
+    expect(mockFileCallback).toHaveBeenCalledTimes(1);
+  });
+
+  it('should handle an empty directory gracefully', async () => {
+    const mockFileCallback: OnFileCallback = vi.fn();
+
+    // Mock FileSystemDirectoryReader
+    const mockDirectoryReader = {
+      readEntries: vi.fn((success: (entries: Array<FileSystemEntry>) => void) => {
+        success([]); // Immediately return no entries
+      })
+    } as unknown as FileSystemDirectoryReader;
+
+    // Mock FileSystemDirectoryEntry
+    const mockDirectoryEntry = {
+      isFile: false,
+      isDirectory: true,
+      name: 'emptyDirectory',
+      createReader: vi.fn(() => mockDirectoryReader)
+    } as unknown as FileSystemDirectoryEntry;
+
+    // Mock DataTransferItem
+    const mockEntry = {
+      webkitGetAsEntry: vi.fn(() => mockDirectoryEntry)
+    } as unknown as DataTransferItem;
+
+    // Mock DataTransferItemList
+    const mockDataTransferItemList = [mockEntry] as unknown as DataTransferItemList;
+
+    // Call the wrapper function
+    await traverseDirectoryTreeWrapper(mockDataTransferItemList, mockFileCallback);
+
+    // Assertions
+    expect(mockFileCallback).not.toHaveBeenCalled(); // Callback should not be invoked
+  });
+});

package/src/functions/__tests__/modelHelper.spec.ts

@@ -88,6 +88,7 @@ describe('model helper tests', () => {
       },
       NavigationCube: {
         Version: '1.0.0',
+        NavCubeGraphicType: 1,
         Transform: {
           Version: '1.0.0',
           AnchorPoint: AnchorPoint.DEFAULT,

package/src/functions/__tests__/tsHelper.spec.ts

@@ -0,0 +1,7 @@
+import { forceType } from '@/functions/tsHelper';
+
+describe('forceType tests', () => {
+  it('should forceType min', () => {
+    expect(forceType<String>('123')).toBeTypeOrNull(String);
+  });
+});

package/src/functions/chunker.ts

@@ -0,0 +1,21 @@
+type WorkerFunction<T> = (arg: T) => Promise<void>;
+
+export class Chunker {
+  static Instantiate() {
+    return new Chunker();
+  }
+
+  async ExecuteInChunks<T>(chunkSize: number, dataSet: T[], worker: WorkerFunction<T>) {
+    const chunks: T[][] = [];
+
+    for (let i = 0; i < dataSet.length; i += chunkSize) {
+      chunks.push(dataSet.slice(i, i + chunkSize));
+    }
+    for (const chunk of chunks) {
+      // NOTE: This is on purpose. We don't want to overwhelm
+      //    the server with requests spawned, so we rate limit to `chunksize` at a time
+      // eslint-disable-next-line no-await-in-loop
+      await Promise.all(chunk.map((x) => worker(x)));
+    }
+  }
+}