@equinor/esv-intersection 3.1.9 → 4.1.0

package/src/layers/WellborePathLayer.ts

@@ -21,14 +21,18 @@ const CURVE_CATMULL_ROM_ALPHA = 0.7;
 const CURVE_CARDINAL_TENSION = 0.9;
 const CURVE_BUNDLE_BETA = 1.0;
 
-export interface WellborepathLayerOptions<T extends [number, number][]> extends LayerOptions<T> {
+export interface WellborepathLayerOptions<
+  T extends [number, number][],
+> extends LayerOptions<T> {
   stroke: string;
   strokeWidth: string;
   curveType?: string;
   tension?: number;
 }
 
-export class WellborepathLayer<T extends [number, number][]> extends SVGLayer<T> {
+export class WellborepathLayer<
+  T extends [number, number][],
+> extends SVGLayer<T> {
   rescaleEvent: OnRescaleEvent | undefined;
 
   constructor(id?: string, options?: WellborepathLayerOptions<T>) {
@@ -62,7 +66,10 @@ export class WellborepathLayer<T extends [number, number][]> extends SVGLayer<T>
     }
     this.elm.select('g').remove();
 
-    const data = this.data || (this.referenceSystem && (this.referenceSystem.projectedPath as [number, number][]));
+    const data =
+      this.data ||
+      (this.referenceSystem &&
+        (this.referenceSystem.projectedPath as [number, number][]));
     if (!data || !this.rescaleEvent) {
       return;
     }
@@ -80,15 +87,21 @@ export class WellborepathLayer<T extends [number, number][]> extends SVGLayer<T>
   private renderWellborePath(data: [number, number][]): string {
     if (this.rescaleEvent != null) {
       const { xScale, yScale } = this.rescaleEvent;
-      const transformedData: [number, number][] = data.map((d) => [xScale(d[0]), yScale(d[1])]);
+      const transformedData: [number, number][] = data.map(d => [
+        xScale(d[0]),
+        yScale(d[1]),
+      ]);
 
       // TODO: Might be a good idea to move something like this to a shared function in a base class
       let curveFactory;
-      const { curveType, tension } = this.options as WellborepathLayerOptions<T>;
+      const { curveType, tension } = this
+        .options as WellborepathLayerOptions<T>;
       switch (curveType) {
         default:
         case 'curveCatmullRom':
-          curveFactory = curveCatmullRom.alpha(tension || CURVE_CATMULL_ROM_ALPHA);
+          curveFactory = curveCatmullRom.alpha(
+            tension || CURVE_CATMULL_ROM_ALPHA,
+          );
           break;
         case 'curveLinear':
           curveFactory = curveLinear;
@@ -103,7 +116,9 @@ export class WellborepathLayer<T extends [number, number][]> extends SVGLayer<T>
           curveFactory = curveBundle.beta(tension || CURVE_BUNDLE_BETA);
           break;
         case 'curveCardinal':
-          curveFactory = curveCardinal.tension(tension || CURVE_CARDINAL_TENSION);
+          curveFactory = curveCardinal.tension(
+            tension || CURVE_CARDINAL_TENSION,
+          );
           break;
         case 'curveMonotoneX':
           curveFactory = curveMonotoneX;

package/src/layers/base/CanvasLayer.ts

@@ -1,5 +1,10 @@
 import { Layer } from './Layer';
-import { OnMountEvent, OnUpdateEvent, OnResizeEvent, OnRescaleEvent } from '../../interfaces';
+import {
+  OnMountEvent,
+  OnUpdateEvent,
+  OnResizeEvent,
+  OnRescaleEvent,
+} from '../../interfaces';
 import { DEFAULT_LAYER_HEIGHT, DEFAULT_LAYER_WIDTH } from '../../constants';
 
 export abstract class CanvasLayer<T> extends Layer<T> {
@@ -45,8 +50,14 @@ export abstract class CanvasLayer<T> extends Layer<T> {
   override onMount(event: OnMountEvent): void {
     super.onMount(event);
     const { elm } = event;
-    const width = event.width || parseInt(elm?.getAttribute('width') ?? '', 10) || DEFAULT_LAYER_WIDTH;
-    const height = event.height || parseInt(elm?.getAttribute('height') ?? '', 10) || DEFAULT_LAYER_HEIGHT;
+    const width =
+      event.width ||
+      parseInt(elm?.getAttribute('width') ?? '', 10) ||
+      DEFAULT_LAYER_WIDTH;
+    const height =
+      event.height ||
+      parseInt(elm?.getAttribute('height') ?? '', 10) ||
+      DEFAULT_LAYER_HEIGHT;
     this.elm = elm;
     let canvas: HTMLCanvasElement;
     if (!this.canvas) {
@@ -89,7 +100,10 @@ export abstract class CanvasLayer<T> extends Layer<T> {
     const flippedX = event.xBounds[0] > event.xBounds[1];
     const flippedY = event.yBounds[0] > event.yBounds[1];
     this.ctx?.translate(event.xScale(0), event.yScale(0));
-    this.ctx?.scale(event.xRatio * (flippedX ? -1 : 1), event.yRatio * (flippedY ? -1 : 1));
+    this.ctx?.scale(
+      event.xRatio * (flippedX ? -1 : 1),
+      event.yRatio * (flippedY ? -1 : 1),
+    );
   }
 
   clearCanvas(): void {

package/src/layers/base/HTMLLayer.ts

@@ -9,8 +9,14 @@ export abstract class HTMLLayer<T> extends Layer<T> {
   override onMount(event: OnMountEvent): void {
     super.onMount(event);
     const { elm } = event;
-    const width = event.width || parseInt(elm?.getAttribute('width') ?? '', 10) || DEFAULT_LAYER_WIDTH;
-    const height = event.height || parseInt(elm?.getAttribute('height') ?? '', 10) || DEFAULT_LAYER_HEIGHT;
+    const width =
+      event.width ||
+      parseInt(elm?.getAttribute('width') ?? '', 10) ||
+      DEFAULT_LAYER_WIDTH;
+    const height =
+      event.height ||
+      parseInt(elm?.getAttribute('height') ?? '', 10) ||
+      DEFAULT_LAYER_HEIGHT;
 
     if (!this.elm) {
       this.elm = select(elm).append('div');
@@ -39,7 +45,9 @@ export abstract class HTMLLayer<T> extends Layer<T> {
       return;
     }
     super.onResize(event);
-    this.elm.style('height', `${event.height}px`).style('width', `${event.width}px`);
+    this.elm
+      .style('height', `${event.height}px`)
+      .style('width', `${event.width}px`);
   }
 
   override setVisibility(visible: boolean): void {

package/src/layers/base/Layer.ts

@@ -1,4 +1,10 @@
-import { OnMountEvent, OnUnmountEvent, OnUpdateEvent, OnRescaleEvent, OnResizeEvent } from '../../interfaces';
+import {
+  OnMountEvent,
+  OnUnmountEvent,
+  OnUpdateEvent,
+  OnRescaleEvent,
+  OnResizeEvent,
+} from '../../interfaces';
 import { IntersectionReferenceSystem } from '../../control';
 
 const defaultOptions = {
@@ -116,7 +122,9 @@ export abstract class Layer<T> {
     return this._referenceSystem;
   }
 
-  set referenceSystem(referenceSystem: IntersectionReferenceSystem | undefined) {
+  set referenceSystem(
+    referenceSystem: IntersectionReferenceSystem | undefined,
+  ) {
     this._referenceSystem = referenceSystem;
   }
 

package/src/layers/base/PixiLayer.ts

@@ -1,6 +1,18 @@
-import { IRenderer, Application, autoDetectRenderer, Container, DisplayObject, IRendererOptionsAuto, Renderer, RENDERER_TYPE } from 'pixi.js';
+import {
+  autoDetectRenderer,
+  AutoDetectOptions,
+  Container,
+  ContainerChild,
+  Renderer,
+  RendererType,
+} from 'pixi.js';
 import { Layer, LayerOptions } from './Layer';
-import { OnMountEvent, OnRescaleEvent, OnResizeEvent, OnUnmountEvent } from '../../interfaces';
+import {
+  OnMountEvent,
+  OnRescaleEvent,
+  OnResizeEvent,
+  OnUnmountEvent,
+} from '../../interfaces';
 import { DEFAULT_LAYER_HEIGHT, DEFAULT_LAYER_WIDTH } from '../../constants';
 
 // PixiRenderApplication has many similarities with PIXI.Application,
@@ -11,9 +23,9 @@ import { DEFAULT_LAYER_HEIGHT, DEFAULT_LAYER_WIDTH } from '../../constants';
 export class PixiRenderApplication {
   stage: Container | undefined;
 
-  renderer: IRenderer<HTMLCanvasElement> | undefined;
+  renderer: Renderer<HTMLCanvasElement> | undefined;
 
-  constructor(pixiRenderOptions?: IRendererOptionsAuto) {
+  async init(pixiRenderOptions?: Partial<AutoDetectOptions>) {
     const options = {
       width: DEFAULT_LAYER_WIDTH,
       height: DEFAULT_LAYER_HEIGHT,
@@ -24,38 +36,12 @@ export class PixiRenderApplication {
       preserveDrawingBuffer: true,
       ...pixiRenderOptions,
     };
-    this.renderer = autoDetectRenderer<HTMLCanvasElement>(options);
+    this.renderer = await autoDetectRenderer(options);
     this.stage = new Container();
   }
 
-  destroy() {
-    this.stage?.destroy({
-      children: true,
-      texture: true,
-      baseTexture: true,
-    });
-    this.stage = undefined;
-
-    // Get renderType and clContext before we destroy the renderer
-    const renderType = this.renderer?.type;
-    const glContext = this.renderer instanceof Renderer ? this.renderer?.gl : undefined;
-
-    /**
-     * WebGL v2 does supposedly not have WEBGL_lose_context
-     * so Pixi.js does not use it to "clean up" on v2.
-     *
-     * Cleaning up our self since it still seems to work and fix issue with lingering context
-     */
-    if (renderType === RENDERER_TYPE.WEBGL && glContext) {
-      glContext?.getExtension('WEBGL_lose_context')?.loseContext();
-    }
-
-    this.renderer?.destroy(true);
-    this.renderer = undefined;
-  }
-
-  get view() {
-    return this.renderer?.view;
+  get canvas() {
+    return this.renderer?.canvas;
   }
 
   render() {
@@ -70,11 +56,14 @@ export abstract class PixiLayer<T> extends Layer<T> {
   private ctx: PixiRenderApplication;
   private container: Container;
 
-  constructor(ctx: Application<HTMLCanvasElement> | PixiRenderApplication, id?: string, options?: LayerOptions<T>) {
+  constructor(
+    ctx: PixiRenderApplication,
+    id?: string,
+    options?: LayerOptions<T>,
+  ) {
     super(id, options);
 
     this.ctx = ctx;
-
     this.container = new Container();
     this.ctx.stage?.addChild(this.container);
   }
@@ -83,13 +72,13 @@ export abstract class PixiLayer<T> extends Layer<T> {
     this.ctx.render();
   }
 
-  addChild(child: DisplayObject) {
+  addChild(child: ContainerChild) {
     this.container.addChild(child);
   }
 
   clearLayer() {
     const children = this.container.removeChildren();
-    children.forEach((child) => {
+    children.forEach(child => {
       child.destroy();
     });
   }
@@ -97,15 +86,16 @@ export abstract class PixiLayer<T> extends Layer<T> {
   override onMount(event: OnMountEvent) {
     super.onMount(event);
 
-    this.pixiViewContainer = this.element?.querySelector('#webgl-layer') ?? undefined;
+    this.pixiViewContainer =
+      this.element?.querySelector('#webgl-layer') ?? undefined;
 
     if (!this.pixiViewContainer) {
       this.pixiViewContainer = document.createElement('div');
       this.pixiViewContainer.setAttribute('id', `${this.id}`);
       this.pixiViewContainer.setAttribute('class', 'webgl-layer');
 
-      if (this.ctx.view != null) {
-        this.pixiViewContainer.appendChild(this.ctx.view);
+      if (this.ctx.canvas != null) {
+        this.pixiViewContainer.appendChild(this.ctx.canvas);
       }
 
       this.element?.appendChild(this.pixiViewContainer);
@@ -135,7 +125,10 @@ export abstract class PixiLayer<T> extends Layer<T> {
     const flippedX = event.xBounds[0] > event.xBounds[1];
     const flippedY = event.yBounds[0] > event.yBounds[1];
     this.setContainerPosition(event.xScale(0), event.yScale(0));
-    this.setContainerScale(event.xRatio * (flippedX ? -1 : 1), event.yRatio * (flippedY ? -1 : 1));
+    this.setContainerScale(
+      event.xRatio * (flippedX ? -1 : 1),
+      event.yRatio * (flippedY ? -1 : 1),
+    );
   }
 
   protected setContainerPosition(x?: number, y?: number) {
@@ -157,7 +150,7 @@ export abstract class PixiLayer<T> extends Layer<T> {
       ['z-index', `${this.order}`],
       ['opacity', `${this.opacity}`],
     ]
-      .map((pair) => pair.join(':'))
+      .map(pair => pair.join(':'))
       .join(';');
 
     this.pixiViewContainer?.setAttribute('style', styles);
@@ -188,7 +181,7 @@ export abstract class PixiLayer<T> extends Layer<T> {
     }
   }
 
-  renderType(): RENDERER_TYPE | undefined {
+  renderType(): RendererType | undefined {
     return this.ctx.renderer?.type;
   }
 }

package/src/layers/base/SVGLayer.ts

@@ -9,8 +9,14 @@ export abstract class SVGLayer<T> extends Layer<T> {
   override onMount(event: OnMountEvent): void {
     super.onMount(event);
     const { elm } = event;
-    const width = event.width || parseInt(elm.getAttribute('width') ?? '', 10) || DEFAULT_LAYER_WIDTH;
-    const height = event.height || parseInt(elm.getAttribute('height') ?? '', 10) || DEFAULT_LAYER_HEIGHT;
+    const width =
+      event.width ||
+      parseInt(elm.getAttribute('width') ?? '', 10) ||
+      DEFAULT_LAYER_WIDTH;
+    const height =
+      event.height ||
+      parseInt(elm.getAttribute('height') ?? '', 10) ||
+      DEFAULT_LAYER_HEIGHT;
     if (!this.elm) {
       this.elm = select(elm).append('svg');
       this.elm.attr('id', `${this.id}`);
@@ -18,7 +24,11 @@ export abstract class SVGLayer<T> extends Layer<T> {
     }
     this.elm.attr('height', height).attr('width', width);
     const interactive = this.interactive ? 'auto' : 'none';
-    this.elm.style('position', 'absolute').style('pointer-events', interactive).style('opacity', this.opacity).style('z-index', this.order);
+    this.elm
+      .style('position', 'absolute')
+      .style('pointer-events', interactive)
+      .style('opacity', this.opacity)
+      .style('z-index', this.order);
   }
 
   override onUnmount(): void {

package/src/layers/schematicInterfaces.ts

@@ -46,7 +46,8 @@ export interface PAndASymbol extends SymbolComponent {
   kind: 'pAndASymbol';
 }
 
-export const isPAndASymbol = (item: PAndA): item is PAndASymbol => item.kind === 'pAndASymbol';
+export const isPAndASymbol = (item: PAndA): item is PAndASymbol =>
+  item.kind === 'pAndASymbol';
 
 export interface CementSqueeze {
   kind: 'cementSqueeze';
@@ -59,7 +60,8 @@ export interface CementSqueeze {
   referenceIds: string[];
 }
 
-export const isCementSqueeze = (item: PAndA): item is CementSqueeze => item.kind === 'cementSqueeze';
+export const isCementSqueeze = (item: PAndA): item is CementSqueeze =>
+  item.kind === 'cementSqueeze';
 
 export interface CementPlug {
   kind: 'cementPlug';
@@ -72,7 +74,8 @@ export interface CementPlug {
   referenceIds: string[];
 }
 
-export const isCementPlug = (item: PAndA): item is CementSqueeze => item.kind === 'cementPlug';
+export const isCementPlug = (item: PAndA): item is CementSqueeze =>
+  item.kind === 'cementPlug';
 
 export type PAndA = PAndASymbol | CementSqueeze | CementPlug;
 
@@ -98,7 +101,11 @@ export interface CompletionSymbol extends BaseCompletion {
 export type Completion = Tubing | Screen | CompletionSymbol;
 
 export const foldCompletion =
-  <T>(fScreen: (obj: Screen) => T, fTubing: (obj: Tubing) => T, fSymbol: (obj: CompletionSymbol) => T) =>
+  <T>(
+    fScreen: (obj: Screen) => T,
+    fTubing: (obj: Tubing) => T,
+    fSymbol: (obj: CompletionSymbol) => T,
+  ) =>
   (completion: Completion): T => {
     switch (completion.kind) {
       case 'screen':
@@ -303,7 +310,8 @@ export function isOpenHoleFracPack(perf: Perforation) {
   );
 }
 
-export const isSubKindCasedHoleFracturation = (perf: Perforation): boolean => perf.subKind === 'Cased hole fracturation';
+export const isSubKindCasedHoleFracturation = (perf: Perforation): boolean =>
+  perf.subKind === 'Cased hole fracturation';
 
 export const intersect = (a: Perforation, b: Perforation): boolean => {
   return a.start < b.end && a.end > b.start;
@@ -330,7 +338,9 @@ export interface InternalLayerOptions {
   perforationLayerId: string;
 }
 
-export const defaultInternalLayerOptions = (layerId: string): InternalLayerOptions => ({
+export const defaultInternalLayerOptions = (
+  layerId: string,
+): InternalLayerOptions => ({
   holeLayerId: `${layerId}-hole`,
   casingLayerId: `${layerId}-casing`,
   completionLayerId: `${layerId}-completion`,

package/src/utils/arc-length.ts

@@ -16,19 +16,40 @@ export class ArcLength {
    * @param {Number} minDepth Min recursive depth before accepting solution
    * @param {Number} maxDepth Max recursive depth
    */
-  static bisect(func: fx, minLimit = 0, maxLimit = 1, tolerance = 0.005, minDepth = 4, maxDepth = 10): number {
-    const calcRec = (a: number, b: number, aVal: number[], bVal: number[], span: number, tolerance: number, depth = 0): number => {
+  static bisect(
+    func: fx,
+    minLimit = 0,
+    maxLimit = 1,
+    tolerance = 0.005,
+    minDepth = 4,
+    maxDepth = 10,
+  ): number {
+    const calcRec = (
+      a: number,
+      b: number,
+      aVal: number[],
+      bVal: number[],
+      span: number,
+      tolerance: number,
+      depth = 0,
+    ): number => {
       const mid = (a + b) / 2;
       const midVal = func(mid) as number[];
       const spanA = Vector2.distance(aVal, midVal);
       const spanB = Vector2.distance(midVal, bVal);
       const length = spanA + spanB;
-      if ((depth >= minDepth && Math.abs(length - span) < tolerance) || depth >= maxDepth) {
+      if (
+        (depth >= minDepth && Math.abs(length - span) < tolerance) ||
+        depth >= maxDepth
+      ) {
         return length;
       }
       const tol = tolerance / 2;
       const d = depth + 1;
-      return calcRec(a, mid, aVal, midVal, spanA, tol, d) + calcRec(mid, b, midVal, bVal, spanB, tol, d);
+      return (
+        calcRec(a, mid, aVal, midVal, spanA, tol, d) +
+        calcRec(mid, b, midVal, bVal, spanB, tol, d)
+      );
     };
     const aVal = func(minLimit) as number[];
     const bVal = func(maxLimit) as number[];
@@ -44,7 +65,12 @@ export class ArcLength {
    * @param {Number} maxLimit Max limit
    * @param {Number} segments Number of segments
    */
-  static trapezoid(func: fx, minLimit = 0, maxLimit = 1, segments = 1000): number {
+  static trapezoid(
+    func: fx,
+    minLimit = 0,
+    maxLimit = 1,
+    segments = 1000,
+  ): number {
     let length = 0;
     let lastPos = func(minLimit) as number[];
     const step = (maxLimit - minLimit) / (segments - 1);

package/src/utils/root-finder.ts

@@ -15,7 +15,14 @@ export class RootFinder {
    * @param {Number} minLimit Min limit of result
    * @param {Number} maxLimit Max limit of result
    */
-  static newton(func: fx, precision = 0.01, maxIterations = 1000, start = 0.5, minLimit = 0, maxLimit = 1): number | undefined {
+  static newton(
+    func: fx,
+    precision = 0.01,
+    maxIterations = 1000,
+    start = 0.5,
+    minLimit = 0,
+    maxLimit = 1,
+  ): number | undefined {
     const h = 0.0001;
     let t = start;
     for (let i = 0; i < maxIterations; i++) {
@@ -38,7 +45,14 @@ export class RootFinder {
    * @param {Number} minLimit Min limit of result
    * @param {Number} maxLimit Max limit of result
    */
-  static bisect(func: fx, precision = 0.01, maxIterations = 1000, start = 0.5, minLimit = 0, maxLimit = 1): number {
+  static bisect(
+    func: fx,
+    precision = 0.01,
+    maxIterations = 1000,
+    start = 0.5,
+    minLimit = 0,
+    maxLimit = 1,
+  ): number {
     let tl = minLimit;
     let th = maxLimit;
     let t = start;
@@ -68,10 +82,24 @@ export class RootFinder {
    * @param {Number} minLimit Min limit of result
    * @param {Number} maxLimit Max limit of result
    */
-  static findRoot(func: fx, precision = 0.01, maxIterations = 1000, start = 0.5, minLimit = 0, maxLimit = 1): number {
+  static findRoot(
+    func: fx,
+    precision = 0.01,
+    maxIterations = 1000,
+    start = 0.5,
+    minLimit = 0,
+    maxLimit = 1,
+  ): number {
     let t = RootFinder.newton(func, precision, maxIterations, start);
     if (t == null) {
-      t = RootFinder.bisect(func, precision, maxIterations, start, minLimit, maxLimit);
+      t = RootFinder.bisect(
+        func,
+        precision,
+        maxIterations,
+        start,
+        minLimit,
+        maxLimit,
+      );
     }
     return t;
   }

package/src/utils/text.ts

@@ -11,11 +11,19 @@ export function pixelsPerUnit(x: ScaleLinear<number, number>): number {
   return Math.abs(x(min + 1));
 }
 
-export function calcSize(factor: number, min: number, max: number, x: ScaleLinear<number, number>): number {
+export function calcSize(
+  factor: number,
+  min: number,
+  max: number,
+  x: ScaleLinear<number, number>,
+): number {
   return clamp(pixelsPerUnit(x) * factor, min, max);
 }
 
-export function isOverlappingHorizontally(r1: BoundingBox, r2: BoundingBox): boolean {
+export function isOverlappingHorizontally(
+  r1: BoundingBox,
+  r2: BoundingBox,
+): boolean {
   const r1x2 = r1.x + r1.width;
   const r2x2 = r2.x + r2.width;
 
@@ -36,13 +44,21 @@ export function isOverlapping(
   const r1y2 = r1.y + r1.height + verticalPadding;
   const r2y2 = r2.y + r2.height + verticalPadding;
 
-  if (r2.x - horizontalPadding > r1x2 || r2.y - verticalPadding > r1y2 || r2x2 + horizontalPadding < r1.x || r2y2 + verticalPadding < r1.y) {
+  if (
+    r2.x - horizontalPadding > r1x2 ||
+    r2.y - verticalPadding > r1y2 ||
+    r2x2 + horizontalPadding < r1.x ||
+    r2y2 + verticalPadding < r1.y
+  ) {
     return false;
   }
   return true;
 }
 
-export function getOverlap(r1: BoundingBox, r2: BoundingBox): { dx: number; dy: number } | undefined {
+export function getOverlap(
+  r1: BoundingBox,
+  r2: BoundingBox,
+): { dx: number; dy: number } | undefined {
   const r1x2 = r1.x + r1.width;
   const r2x2 = r2.x + r2.width;
   const r1y2 = r1.y + r1.height;
@@ -52,8 +68,14 @@ export function getOverlap(r1: BoundingBox, r2: BoundingBox): { dx: number; dy:
     return undefined;
   }
 
-  const dx = Math.max(0, Math.min(r1.x + r1.width, r2.x + r2.width) - Math.max(r1.x, r2.x));
-  const dy = Math.max(0, Math.min(r1.y + r1.height, r2.y + r2.height) - Math.max(r1.y, r2.y));
+  const dx = Math.max(
+    0,
+    Math.min(r1.x + r1.width, r2.x + r2.width) - Math.max(r1.x, r2.x),
+  );
+  const dy = Math.max(
+    0,
+    Math.min(r1.y + r1.height, r2.y + r2.height) - Math.max(r1.y, r2.y),
+  );
 
   const newPoints = {
     dx,
@@ -73,7 +95,12 @@ export function getOverlapOffset(
   const r1y2 = r1.y + r1.height;
   const r2y2 = r2.y + r2.height;
 
-  if (r2.x - horizontalPadding > r1x2 || r2.y - verticalPadding > r1y2 || r2x2 + horizontalPadding < r1.x || r2y2 + verticalPadding < r1.y) {
+  if (
+    r2.x - horizontalPadding > r1x2 ||
+    r2.y - verticalPadding > r1y2 ||
+    r2x2 + horizontalPadding < r1.x ||
+    r2y2 + verticalPadding < r1.y
+  ) {
     return undefined;
   }
 

package/src/utils/vectorUtils.ts

@@ -1,14 +1,21 @@
-import { IPoint, Point } from 'pixi.js';
+import { Point } from 'pixi.js';
 import Vector2 from '@equinor/videx-vector2';
 
-export const pointToVector = (p: IPoint): Vector2 => new Vector2(p.x, p.y);
-export const pointToArray = (p: IPoint): [number, number] => [p.x, p.y];
+export const pointToVector = (p: Point): Vector2 => new Vector2(p.x, p.y);
+export const pointToArray = (p: Point): [number, number] => [p.x, p.y];
 export const vectorToPoint = (v: Vector2): Point => new Point(v[0], v[1]);
-export const vectorToArray = (v: Vector2): [number, number] => [v[0] ?? 0, v[1] ?? 0];
+export const vectorToArray = (v: Vector2): [number, number] => [
+  v[0] ?? 0,
+  v[1] ?? 0,
+];
 export const arrayToPoint = (a: number[]): Point => new Point(a[0], a[1]);
-export const arrayToVector = (a: number[]): Vector2 => new Vector2(a[0] ?? 0, a[1] ?? 0);
+export const arrayToVector = (a: number[]): Vector2 =>
+  new Vector2(a[0] ?? 0, a[1] ?? 0);
 
-export const calcDist = (prev: [number, number], point: [number, number]): number => {
+export const calcDist = (
+  prev: [number, number],
+  point: [number, number],
+): number => {
   return arrayToVector(point).sub(prev).magnitude;
 };
 
@@ -27,7 +34,7 @@ export const convertToUnitVector = (p: Point): Point => {
   return vectorToPoint(pointToVector(p).normalize());
 };
 
-export const createNormals = (points: IPoint[]): Vector2[] => {
+export const createNormals = (points: Point[]): Vector2[] => {
   if (points.length < 2) {
     return [new Vector2(0)];
   }
@@ -53,12 +60,20 @@ export const createNormals = (points: IPoint[]): Vector2[] => {
 };
 
 // TODO check if this can be simplified and return Vector/number[]
-export const offsetPoint = (point: IPoint, vector: Vector2, offset: number): Point => {
+export const offsetPoint = (
+  point: Point,
+  vector: Vector2,
+  offset: number,
+): Point => {
   const p = pointToVector(point);
   return vectorToPoint(p.add(vector.scale(offset)));
 };
 
-export const offsetPoints = (points: IPoint[], vectors: Vector2[], offset: number): Point[] => {
+export const offsetPoints = (
+  points: Point[],
+  vectors: Vector2[],
+  offset: number,
+): Point[] => {
   if (points.length !== vectors.length) {
     throw new Error('Number of vectors does not match number of points');
   }
@@ -69,6 +84,8 @@ export const offsetPoints = (points: IPoint[], vectors: Vector2[], offset: numbe
     if (vector != null) {
       return offsetPoint(point, vector, offset);
     }
-    throw new Error(`Trying to read index ${index} of point ${point}, but no such vector was found!`);
+    throw new Error(
+      `Trying to read index ${index} of point ${point}, but no such vector was found!`,
+    );
   });
 };