@3cr/viewer-browser 0.0.200 → 0.0.246

package/src/types/colour.ts

@@ -0,0 +1,6 @@
+export interface Colour {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+}

package/src/types/data-overlay-angle.ts

@@ -0,0 +1,16 @@
+import { InvertTransformData, Vector3Data } from '@3cr/types-ts';
+import { DataOverlay, DataOverlayRaw } from '@/types/data-overlay';
+import { SegmentAngle } from '@/types/segment-angle';
+
+interface DataOverlayAngleBase {
+  Points: Vector3Data[];
+  Inverted: InvertTransformData;
+  Visibility2d: boolean | null;
+  Visibility3d: boolean | null;
+  SegmentAngles: SegmentAngle[];
+  Units: string;
+}
+
+export type DataOverlayAngle = DataOverlayAngleBase & DataOverlay;
+
+export type DataOverlayAngleRaw = DataOverlayAngleBase & DataOverlayRaw;

package/src/types/data-overlay-annotation.ts

@@ -0,0 +1,18 @@
+import { Vector3Data, InvertTransformData, ColourData, Vector2Data } from '@3cr/types-ts';
+import { DataOverlay, DataOverlayRaw } from '@/types/data-overlay';
+
+interface DataOverlayAnnotationBase {
+  Position: Vector3Data;
+  Inverted: InvertTransformData;
+  Colour2d: ColourData;
+  Colour3d: ColourData;
+  Size2d: Vector2Data;
+  Size3d: Vector3Data;
+  Icon2d: string;
+  Visibility2d: boolean | null;
+  Visibility3d: boolean | null;
+}
+
+export type DataOverlayAnnotation = DataOverlayAnnotationBase & DataOverlay;
+
+export type DataOverlayAnnotationRaw = DataOverlayAnnotationBase & DataOverlayRaw;

package/src/types/data-overlay-data.ts

@@ -0,0 +1,15 @@
+import { DataOverlayType } from '@3cr/types-ts/types/DataOverlayType';
+
+interface DataOverlayDataBase {
+  Version: string;
+  Id: string;
+  DataType: DataOverlayType;
+}
+
+export interface DataOverlayData<T> extends DataOverlayDataBase {
+  Data: T;
+}
+
+export interface DataOverlayDataRaw extends DataOverlayDataBase {
+  Data: string;
+}

package/src/types/data-overlay-event.ts

@@ -0,0 +1,5 @@
+import { DataOverlay } from '@/types/data-overlay';
+import { DataOverlayData } from '@/types/data-overlay-data';
+import { DataOverlayInteraction } from '@/types/data-overlay-interaction';
+
+export type DataOverlayEvent<T extends DataOverlay> = DataOverlayData<DataOverlayInteraction<T>>;

package/src/types/data-overlay-info.ts

@@ -0,0 +1,18 @@
+export interface DataOverlayInfo {
+  id: string;
+  title: string;
+  target: [number, number];
+  data: {
+    icon: string;
+    title: string;
+    subtitle?: string;
+    data?: {
+      key: string;
+      value: string;
+    }[];
+    actions?: {
+      url: string;
+      description: string;
+    }[];
+  }[];
+}

package/src/types/data-overlay-interaction.ts

@@ -0,0 +1,15 @@
+import { Interactiontype } from '@3cr/types-ts/types/Interactiontype';
+import { DataOverlay, DataOverlayRaw } from '@/types/data-overlay';
+
+interface DataOverlayInteractionBase {
+  Version: string;
+  Interaction: Interactiontype;
+}
+
+export interface DataOverlayInteraction<T extends DataOverlay> extends DataOverlayInteractionBase {
+  DataOverlay: T;
+}
+
+export interface DataOverlayInteractionRaw<T extends DataOverlayRaw> extends DataOverlayInteractionBase {
+  DataOverlay: T;
+}

package/src/types/data-overlay-length.ts

@@ -0,0 +1,16 @@
+import { InvertTransformData, Vector3Data } from '@3cr/types-ts';
+import { DataOverlay, DataOverlayRaw } from '@/types/data-overlay';
+
+interface DataOverlayLengthBase {
+  Points: Vector3Data[];
+  Inverted: InvertTransformData;
+  Visibility2d: boolean | null;
+  Visibility3d: boolean | null;
+  SegmentLengths: number[];
+  TotalLength: number;
+  Units: string;
+}
+
+export type DataOverlayLength = DataOverlayLengthBase & DataOverlay;
+
+export type DataOverlayLengthRaw = DataOverlayLengthBase & DataOverlayRaw;

package/src/types/data-overlay-markup.ts

@@ -0,0 +1,7 @@
+import { DataOverlayLength, DataOverlayLengthRaw } from '@/types/data-overlay-length';
+import { DataOverlayPolygon, DataOverlayPolygonRaw } from '@/types/data-overlay-polygon';
+import { DataOverlayAngle, DataOverlayAngleRaw } from '@/types/data-overlay-angle';
+
+export type DataOverlayMarkup = DataOverlayLength | DataOverlayPolygon | DataOverlayAngle;
+
+export type DataOverlayMarkupRaw = DataOverlayLengthRaw | DataOverlayPolygonRaw | DataOverlayAngleRaw;

package/src/types/data-overlay-mcad.ts

@@ -0,0 +1,20 @@
+import { Vector3Data } from '@3cr/types-ts/types/Vector3Data';
+import { InvertTransformData } from '@3cr/types-ts/types/InvertTransformData';
+import { ColourData } from '@3cr/types-ts/types/ColourData';
+import { DataOverlay, DataOverlayRaw } from '@/types/data-overlay';
+import { OrientationSetting } from '@3cr/types-ts/types/OrientationSetting';
+
+export interface DataOverlayMcadBase {
+  Position: Vector3Data;
+  Rotation: Vector3Data;
+  Scale: Vector3Data;
+  Inverted: InvertTransformData;
+  Colour: ColourData;
+  Visibility: boolean;
+  Key: string;
+  Orientation: OrientationSetting;
+}
+
+export type DataOverlayMcad = DataOverlayMcadBase & DataOverlay;
+
+export type DataOverlayMcadRaw = DataOverlayMcadBase & DataOverlayRaw;

package/src/types/data-overlay-polygon.ts

@@ -0,0 +1,18 @@
+import { InvertTransformData, Vector3Data } from '@3cr/types-ts';
+import { DataOverlay, DataOverlayRaw } from '@/types/data-overlay';
+
+interface DataOverlayPolygonBase {
+  Points: Vector3Data[];
+  Inverted: InvertTransformData;
+  Visibility2d: boolean | null;
+  Visibility3d: boolean | null;
+  Area: number;
+  Perimeter: number;
+  AverageHU: number;
+  LowestHU: number;
+  HighestHU: number;
+}
+
+export type DataOverlayPolygon = DataOverlayPolygonBase & DataOverlay;
+
+export type DataOverlayPolygonRaw = DataOverlayPolygonBase & DataOverlayRaw;

package/src/types/data-overlay.ts

@@ -0,0 +1,16 @@
+import { CallToAction } from '@/types/call-to-action';
+
+interface DataOverlayBase {
+  Version: string;
+  Id: string;
+  Title: string;
+  Description: string;
+}
+
+export interface DataOverlay extends DataOverlayBase {
+  CallToAction: CallToAction | null;
+}
+
+export interface DataOverlayRaw extends DataOverlayBase {
+  CallToAction: string | null;
+}

package/src/types/demo-type.ts

@@ -0,0 +1,4 @@
+export enum DemoType {
+  Patient,
+  Licence
+}

package/src/types/gpt-question.ts

@@ -0,0 +1,4 @@
+export interface GptQuestion {
+  Question: string;
+  ApiPreFilledRequestKey: number;
+}

package/src/types/gpt-response-payload.ts

@@ -0,0 +1,6 @@
+import { GptQuestion } from '@/types/gpt-question';
+
+export interface GptResponsePayload {
+  GptResponse: string;
+  FollowupQuestions: GptQuestion[];
+}

package/src/types/mcad-object-interaction.ts

@@ -0,0 +1,15 @@
+import { Interactiontype } from '@3cr/types-ts/types/Interactiontype';
+import { DataOverlayMcad, DataOverlayMcadRaw } from '@/types/data-overlay-mcad';
+
+interface McadObjectInteractionBase {
+  Version: string;
+  Interaction: Interactiontype;
+}
+
+export interface McadObjectInteraction extends McadObjectInteractionBase {
+  Mcad: DataOverlayMcad;
+}
+
+export interface McadObjectInteractionRaw extends McadObjectInteractionBase {
+  Mcad: DataOverlayMcadRaw;
+}

package/src/types/segment-angle.ts

@@ -0,0 +1,5 @@
+export interface SegmentAngle {
+  Version: string;
+  Acute: number;
+  Reflex: number;
+}

package/src/types/vector2.ts

@@ -0,0 +1,4 @@
+export interface Vector2 {
+  x: number;
+  y: number;
+}

package/src/types/vector3.ts

@@ -0,0 +1,5 @@
+export interface Vector3 {
+  x: number;
+  y: number;
+  z: number;
+}

package/test/fakers/action-data.faker.ts

@@ -0,0 +1,11 @@
+import { ActionData } from '@/types/action-data';
+import { faker } from '@faker-js/faker';
+
+export class ActionDataFaker {
+  static random(): ActionData {
+    return {
+      Description: faker.lorem.text(),
+      Url: faker.internet.url()
+    };
+  }
+}

package/test/fakers/action.faker.ts

@@ -0,0 +1,19 @@
+import { Action, ActionRaw } from '@/types/action';
+import { faker } from '@faker-js/faker';
+import { ActionDataFaker } from '@test/fakers/action-data.faker';
+
+export class ActionFaker {
+  static random(): Action {
+    return {
+      ActionType: faker.number.int(),
+      ActionData: ActionDataFaker.random()
+    };
+  }
+
+  static randomRaw(): ActionRaw {
+    return {
+      ActionType: faker.number.int(),
+      ActionData: JSON.stringify(ActionDataFaker.random())
+    };
+  }
+}

package/test/fakers/call-to-action.faker.ts

@@ -0,0 +1,17 @@
+import { CallToAction, CallToActionRaw } from '@/types/call-to-action';
+import { faker } from '@faker-js/faker';
+import { ActionFaker } from '@test/fakers/action.faker';
+
+export class CallToActionFaker {
+  static random(): CallToAction {
+    return {
+      Actions: faker.helpers.multiple(ActionFaker.random, { count: { min: 1, max: 10 } })
+    };
+  }
+
+  static randomRaw(): CallToActionRaw {
+    return {
+      Actions: faker.helpers.multiple(ActionFaker.randomRaw, { count: { min: 1, max: 10 } })
+    };
+  }
+}

package/test/fakers/colour.faker.ts

@@ -0,0 +1,17 @@
+import { ColourData } from '@3cr/types-ts';
+import { faker } from '@faker-js/faker';
+
+/**
+ * Create fake ColourData objects.
+ */
+export class ColourFaker {
+  static random(): ColourData {
+    return {
+      Version: faker.system.semver(),
+      R: faker.number.float(),
+      G: faker.number.float(),
+      B: faker.number.float(),
+      A: faker.number.float()
+    };
+  }
+}

package/test/fakers/data-overlay-angle.faker.ts

@@ -0,0 +1,37 @@
+import { DataOverlayAngle, DataOverlayAngleRaw } from '@/types/data-overlay-angle';
+import { faker } from '@faker-js/faker';
+import { Vector3Faker } from '@test/fakers/vector3.faker';
+import { InvertTransformFaker } from '@test/fakers/invert-transform.faker';
+import { SegmentAngleFaker } from '@test/fakers/segment-angle.faker';
+import { CallToActionFaker } from '@test/fakers/call-to-action.faker';
+
+export class DataOverlayAngleFaker {
+  static random(): DataOverlayAngle {
+    return {
+      ...DataOverlayAngleFaker.randomBase(),
+      CallToAction: CallToActionFaker.random()
+    };
+  }
+
+  static randomRaw(): DataOverlayAngleRaw {
+    return {
+      ...DataOverlayAngleFaker.randomBase(),
+      CallToAction: JSON.stringify(CallToActionFaker.randomRaw())
+    };
+  }
+
+  private static randomBase() {
+    return {
+      Version: faker.system.semver(),
+      Id: faker.string.uuid(),
+      Title: faker.lorem.word(),
+      Description: faker.lorem.word(),
+      Points: faker.helpers.multiple(Vector3Faker.random, { count: 3 }),
+      Inverted: InvertTransformFaker.random(),
+      Visibility2d: faker.datatype.boolean(),
+      Visibility3d: faker.datatype.boolean(),
+      SegmentAngles: faker.helpers.multiple(SegmentAngleFaker.random, { count: 1 }),
+      Units: faker.science.unit().symbol
+    };
+  }
+}

package/test/fakers/data-overlay-annotation.faker.ts

@@ -0,0 +1,41 @@
+import { faker } from '@faker-js/faker';
+import { DataOverlayAnnotation, DataOverlayAnnotationRaw } from '@/types/data-overlay-annotation';
+import { Vector3Faker } from '@test/fakers/vector3.faker';
+import { InvertTransformFaker } from '@test/fakers/invert-transform.faker';
+import { ColourFaker } from '@test/fakers/colour.faker';
+import { Vector2Faker } from '@test/fakers/vector2.faker';
+import { CallToActionFaker } from '@test/fakers/call-to-action.faker';
+
+export class DataOverlayAnnotationFaker {
+  static random(): DataOverlayAnnotation {
+    return {
+      ...DataOverlayAnnotationFaker.randomBase(),
+      CallToAction: CallToActionFaker.random()
+    };
+  }
+
+  static randomRaw(): DataOverlayAnnotationRaw {
+    return {
+      ...DataOverlayAnnotationFaker.randomBase(),
+      CallToAction: JSON.stringify(CallToActionFaker.randomRaw())
+    };
+  }
+
+  private static randomBase() {
+    return {
+      Version: faker.system.semver(),
+      Id: faker.string.uuid(),
+      Title: faker.lorem.word(),
+      Description: faker.lorem.word(),
+      Position: Vector3Faker.random(),
+      Inverted: InvertTransformFaker.random(),
+      Colour2d: ColourFaker.random(),
+      Colour3d: ColourFaker.random(),
+      Size2d: Vector2Faker.random(),
+      Size3d: Vector3Faker.random(),
+      Icon2d: '',
+      Visibility2d: faker.datatype.boolean(),
+      Visibility3d: faker.datatype.boolean()
+    };
+  }
+}

package/test/fakers/data-overlay-data.faker.ts

@@ -0,0 +1,97 @@
+import { DataOverlayData, DataOverlayDataRaw } from '@/types/data-overlay-data';
+import { DataOverlayAnnotation } from '@/types/data-overlay-annotation';
+import { faker } from '@faker-js/faker';
+import { DataOverlayAnnotationFaker } from '@test/fakers/data-overlay-annotation.faker';
+import { DataOverlayAngle } from '@/types/data-overlay-angle';
+import { DataOverlayAngleFaker } from '@test/fakers/data-overlay-angle.faker';
+import { DataOverlayLength } from '@/types/data-overlay-length';
+import { DataOverlayLengthFaker } from '@test/fakers/data-overlay-length.faker';
+import { DataOverlayPolygon } from '@/types/data-overlay-polygon';
+import { DataOverlayPolygonFaker } from '@test/fakers/data-overlay-polygon.faker';
+import { DataOverlayType, Interactiontype } from '@3cr/types-ts';
+import { DataOverlayInteraction } from '@/types/data-overlay-interaction';
+import { DataOverlayInteractionFaker } from '@test/fakers/data-overlay-interaction.faker';
+
+export class DataOverlayDataFaker {
+  static annotation(): DataOverlayData<DataOverlayAnnotation> {
+    return DataOverlayDataFaker.random(DataOverlayAnnotationFaker.random(), DataOverlayType.Annotation);
+  }
+
+  static annotationEvent(type: Interactiontype): DataOverlayData<DataOverlayInteraction<DataOverlayAnnotation>> {
+    return DataOverlayDataFaker.random(DataOverlayInteractionFaker.annotation(type), DataOverlayType.Annotation);
+  }
+
+  static annotationRaw(): DataOverlayDataRaw {
+    return DataOverlayDataFaker.randomRaw(DataOverlayAnnotationFaker.randomRaw(), DataOverlayType.Annotation);
+  }
+
+  static annotationEventRaw(type: Interactiontype): DataOverlayDataRaw {
+    return DataOverlayDataFaker.randomRaw(DataOverlayInteractionFaker.annotationRaw(type), DataOverlayType.Annotation);
+  }
+
+  static length(): DataOverlayData<DataOverlayLength> {
+    return DataOverlayDataFaker.random(DataOverlayLengthFaker.random(), DataOverlayType.Length);
+  }
+
+  static lengthEvent(type: Interactiontype): DataOverlayData<DataOverlayInteraction<DataOverlayLength>> {
+    return DataOverlayDataFaker.random(DataOverlayInteractionFaker.length(type), DataOverlayType.Length);
+  }
+
+  static lengthRaw(): DataOverlayDataRaw {
+    return DataOverlayDataFaker.randomRaw(DataOverlayLengthFaker.randomRaw(), DataOverlayType.Length);
+  }
+
+  static lengthEventRaw(type: Interactiontype): DataOverlayDataRaw {
+    return DataOverlayDataFaker.randomRaw(DataOverlayInteractionFaker.lengthRaw(type), DataOverlayType.Length);
+  }
+
+  static polygon(): DataOverlayData<DataOverlayPolygon> {
+    return DataOverlayDataFaker.random(DataOverlayPolygonFaker.random(), DataOverlayType.Polygon);
+  }
+
+  static polygonEvent(type: Interactiontype): DataOverlayData<DataOverlayInteraction<DataOverlayPolygon>> {
+    return DataOverlayDataFaker.random(DataOverlayInteractionFaker.polygon(type), DataOverlayType.Polygon);
+  }
+
+  static polygonRaw(): DataOverlayDataRaw {
+    return DataOverlayDataFaker.randomRaw(DataOverlayPolygonFaker.randomRaw(), DataOverlayType.Polygon);
+  }
+
+  static polygonEventRaw(type: Interactiontype): DataOverlayDataRaw {
+    return DataOverlayDataFaker.randomRaw(DataOverlayInteractionFaker.polygonRaw(type), DataOverlayType.Polygon);
+  }
+
+  static angle(): DataOverlayData<DataOverlayAngle> {
+    return DataOverlayDataFaker.random(DataOverlayAngleFaker.random(), DataOverlayType.Angle);
+  }
+
+  static angleEvent(type: Interactiontype): DataOverlayData<DataOverlayInteraction<DataOverlayAngle>> {
+    return DataOverlayDataFaker.random(DataOverlayInteractionFaker.angle(type), DataOverlayType.Angle);
+  }
+
+  static angleRaw(): DataOverlayDataRaw {
+    return DataOverlayDataFaker.randomRaw(DataOverlayAngleFaker.randomRaw(), DataOverlayType.Angle);
+  }
+
+  static angleEventRaw(type: Interactiontype): DataOverlayDataRaw {
+    return DataOverlayDataFaker.randomRaw(DataOverlayInteractionFaker.angleRaw(type), DataOverlayType.Angle);
+  }
+
+  private static random<T>(data: T, dataType: DataOverlayType): DataOverlayData<T> {
+    return {
+      Version: faker.system.semver(),
+      Id: faker.string.uuid(),
+      DataType: dataType,
+      Data: data
+    };
+  }
+
+  private static randomRaw<T>(data: T, dataType: DataOverlayType): DataOverlayDataRaw {
+    return {
+      Version: faker.system.semver(),
+      Id: faker.string.uuid(),
+      DataType: dataType,
+      Data: JSON.stringify(data)
+    };
+  }
+}

package/test/fakers/data-overlay-info.faker.ts

@@ -0,0 +1,29 @@
+import { DataOverlayInfo } from '@/types/data-overlay-info';
+import { faker } from '@faker-js/faker';
+
+export class DataOverlayInfoFaker {
+  static random(data: number = 3): DataOverlayInfo {
+    return {
+      id: faker.string.uuid(),
+      title: faker.lorem.word(),
+      target: [faker.number.int(), faker.number.int()],
+      data: faker.helpers.multiple(DataOverlayInfoFaker.data, { count: data })
+    };
+  }
+
+  private static data() {
+    return {
+      icon: 'description',
+      title: faker.lorem.word(),
+      subtitle: faker.lorem.word(),
+      actions: faker.helpers.multiple(DataOverlayInfoFaker.actions, { count: 3 })
+    };
+  }
+
+  private static actions() {
+    return {
+      url: faker.internet.url(),
+      description: faker.lorem.text()
+    };
+  }
+}

package/test/fakers/data-overlay-interaction.faker.ts

@@ -0,0 +1,62 @@
+import { DataOverlayInteraction, DataOverlayInteractionRaw } from '@/types/data-overlay-interaction';
+import { DataOverlayAnnotation, DataOverlayAnnotationRaw } from '@/types/data-overlay-annotation';
+import { DataOverlayAnnotationFaker } from '@test/fakers/data-overlay-annotation.faker';
+import { DataOverlayLength, DataOverlayLengthRaw } from '@/types/data-overlay-length';
+import { DataOverlayLengthFaker } from '@test/fakers/data-overlay-length.faker';
+import { DataOverlayPolygon, DataOverlayPolygonRaw } from '@/types/data-overlay-polygon';
+import { DataOverlayPolygonFaker } from '@test/fakers/data-overlay-polygon.faker';
+import { DataOverlayAngle, DataOverlayAngleRaw } from '@/types/data-overlay-angle';
+import { DataOverlayAngleFaker } from '@test/fakers/data-overlay-angle.faker';
+import { DataOverlay, DataOverlayRaw } from '@/types/data-overlay';
+import { faker } from '@faker-js/faker';
+import { Interactiontype } from '@3cr/types-ts';
+
+export class DataOverlayInteractionFaker {
+  static annotation(interaction: Interactiontype): DataOverlayInteraction<DataOverlayAnnotation> {
+    return DataOverlayInteractionFaker.random(DataOverlayAnnotationFaker.random(), interaction);
+  }
+
+  static annotationRaw(interaction: Interactiontype): DataOverlayInteractionRaw<DataOverlayAnnotationRaw> {
+    return DataOverlayInteractionFaker.randomRaw(DataOverlayAnnotationFaker.randomRaw(), interaction);
+  }
+
+  static length(interaction: Interactiontype): DataOverlayInteraction<DataOverlayLength> {
+    return DataOverlayInteractionFaker.random(DataOverlayLengthFaker.random(), interaction);
+  }
+
+  static lengthRaw(interaction: Interactiontype): DataOverlayInteractionRaw<DataOverlayLengthRaw> {
+    return DataOverlayInteractionFaker.randomRaw(DataOverlayLengthFaker.randomRaw(), interaction);
+  }
+
+  static polygon(interaction: Interactiontype): DataOverlayInteraction<DataOverlayPolygon> {
+    return DataOverlayInteractionFaker.random(DataOverlayPolygonFaker.random(), interaction);
+  }
+
+  static polygonRaw(interaction: Interactiontype): DataOverlayInteractionRaw<DataOverlayPolygonRaw> {
+    return DataOverlayInteractionFaker.randomRaw(DataOverlayPolygonFaker.randomRaw(), interaction);
+  }
+
+  static angle(interaction: Interactiontype): DataOverlayInteraction<DataOverlayAngle> {
+    return DataOverlayInteractionFaker.random(DataOverlayAngleFaker.random(), interaction);
+  }
+
+  static angleRaw(interaction: Interactiontype): DataOverlayInteractionRaw<DataOverlayAngleRaw> {
+    return DataOverlayInteractionFaker.randomRaw(DataOverlayAngleFaker.randomRaw(), interaction);
+  }
+
+  private static random<T extends DataOverlay>(data: T, type: Interactiontype): DataOverlayInteraction<T> {
+    return {
+      Version: faker.system.semver(),
+      DataOverlay: data,
+      Interaction: type
+    };
+  }
+
+  private static randomRaw<T extends DataOverlayRaw>(data: T, type: Interactiontype): DataOverlayInteractionRaw<T> {
+    return {
+      Version: faker.system.semver(),
+      DataOverlay: data,
+      Interaction: type
+    };
+  }
+}

package/test/fakers/data-overlay-length.faker.ts

@@ -0,0 +1,37 @@
+import { DataOverlayLength, DataOverlayLengthRaw } from '@/types/data-overlay-length';
+import { faker } from '@faker-js/faker';
+import { CallToActionFaker } from '@test/fakers/call-to-action.faker';
+import { Vector3Faker } from '@test/fakers/vector3.faker';
+import { InvertTransformFaker } from '@test/fakers/invert-transform.faker';
+
+export class DataOverlayLengthFaker {
+  static random(): DataOverlayLength {
+    return {
+      ...DataOverlayLengthFaker.randomBase(),
+      CallToAction: CallToActionFaker.random()
+    };
+  }
+
+  static randomRaw(): DataOverlayLengthRaw {
+    return {
+      ...DataOverlayLengthFaker.randomBase(),
+      CallToAction: JSON.stringify(CallToActionFaker.randomRaw())
+    };
+  }
+
+  private static randomBase() {
+    return {
+      Version: faker.system.semver(),
+      Id: faker.string.uuid(),
+      Title: faker.lorem.word(),
+      Description: faker.lorem.word(),
+      Points: faker.helpers.multiple(Vector3Faker.random, { count: 5 }),
+      Inverted: InvertTransformFaker.random(),
+      Visibility2d: faker.datatype.boolean(),
+      Visibility3d: faker.datatype.boolean(),
+      SegmentLengths: faker.helpers.multiple(faker.number.float, { count: 4 }),
+      TotalLength: faker.number.float(),
+      Units: faker.science.unit().symbol
+    };
+  }
+}

package/test/fakers/data-overlay-mcad.faker.ts

@@ -0,0 +1,40 @@
+import { DataOverlayMcad, DataOverlayMcadRaw } from '@/types/data-overlay-mcad';
+import { faker } from '@faker-js/faker';
+import { CallToActionFaker } from '@test/fakers/call-to-action.faker';
+import { Vector3Faker } from '@test/fakers/vector3.faker';
+import { InvertTransformFaker } from '@test/fakers/invert-transform.faker';
+import { ColourFaker } from '@test/fakers/colour.faker';
+import { OrientationFaker } from '@test/fakers/orientation.faker';
+
+export class DataOverlayMcadFaker {
+  static random(): DataOverlayMcad {
+    return {
+      ...DataOverlayMcadFaker.randomBase(),
+      CallToAction: CallToActionFaker.random()
+    };
+  }
+
+  static randomRaw(): DataOverlayMcadRaw {
+    return {
+      ...DataOverlayMcadFaker.randomBase(),
+      CallToAction: JSON.stringify(CallToActionFaker.randomRaw())
+    };
+  }
+
+  private static randomBase() {
+    return {
+      Version: faker.system.semver(),
+      Id: faker.string.uuid(),
+      Title: faker.lorem.word(),
+      Description: faker.lorem.text(),
+      Position: Vector3Faker.random(),
+      Rotation: Vector3Faker.random(),
+      Scale: Vector3Faker.random(),
+      Inverted: InvertTransformFaker.random(),
+      Colour: ColourFaker.random(),
+      Visibility: faker.datatype.boolean(),
+      Key: faker.string.uuid(),
+      Orientation: OrientationFaker.random()
+    };
+  }
+}