@equinor/esv-intersection 4.0.0 → 4.1.1

package/src/layers/CalloutCanvasLayer.ts

@@ -1,7 +1,12 @@
 import { ScaleLinear } from 'd3-scale';
 
 import { CanvasLayer } from './base/CanvasLayer';
-import { OnUpdateEvent, Annotation, OnRescaleEvent, BoundingBox } from '../interfaces';
+import {
+  OnUpdateEvent,
+  Annotation,
+  OnRescaleEvent,
+  BoundingBox,
+} from '../interfaces';
 import { calcSize, isOverlapping, getOverlapOffset } from '../utils';
 import { LayerOptions } from './base/Layer';
 
@@ -46,7 +51,9 @@ export type Callout = {
   dy: number;
 };
 
-export interface CalloutOptions<T extends Annotation[]> extends LayerOptions<T> {
+export interface CalloutOptions<
+  T extends Annotation[],
+> extends LayerOptions<T> {
   minFontSize?: number;
   maxFontSize?: number;
   fontSizeFactor?: number;
@@ -98,8 +105,12 @@ export class CalloutCanvasLayer<T extends Annotation[]> extends CanvasLayer<T> {
       this.backgroundColor = DEFAULT_BACKGROUND_COLOR;
     }
 
-    this.backgroundPadding = options?.backgroundPadding || DEFAULT_BACKGROUND_PADDING;
-    this.backgroundBorderRadius = getValueOrDefault(options?.backgroundBorderRadius, DEFAULT_BACKGROUND_BORDER_RADIUS);
+    this.backgroundPadding =
+      options?.backgroundPadding || DEFAULT_BACKGROUND_PADDING;
+    this.backgroundBorderRadius = getValueOrDefault(
+      options?.backgroundBorderRadius,
+      DEFAULT_BACKGROUND_BORDER_RADIUS,
+    );
   }
 
   setGroupFilter(filter: string[]): void {
@@ -116,7 +127,8 @@ export class CalloutCanvasLayer<T extends Annotation[]> extends CanvasLayer<T> {
 
   override onRescale(event: OnRescaleEvent): void {
     super.onRescale(event);
-    const isPanning = this.rescaleEvent && this.rescaleEvent.xRatio === event.xRatio;
+    const isPanning =
+      this.rescaleEvent && this.rescaleEvent.xRatio === event.xRatio;
     this.rescaleEvent = event;
 
     this.render(isPanning);
@@ -132,21 +144,45 @@ export class CalloutCanvasLayer<T extends Annotation[]> extends CanvasLayer<T> {
 
       const { xScale, yScale, xBounds } = this.rescaleEvent;
 
-      const fontSize = calcSize(this.fontSizeFactor, this.minFontSize, this.maxFontSize, xScale);
+      const fontSize = calcSize(
+        this.fontSizeFactor,
+        this.minFontSize,
+        this.maxFontSize,
+        xScale,
+      );
 
       if (!isPanning || this.callouts.length <= 0) {
         const { data, ctx, groupFilter } = this;
-        const { calculateDisplacementFromBottom } = this.referenceSystem.options;
-        const isLeftToRight = calculateDisplacementFromBottom ? xBounds[0] < xBounds[1] : xBounds[0] > xBounds[1];
+        const { calculateDisplacementFromBottom } =
+          this.referenceSystem.options;
+        const isLeftToRight = calculateDisplacementFromBottom
+          ? xBounds[0] < xBounds[1]
+          : xBounds[0] > xBounds[1];
         const scale = 0;
 
         ctx != null && (ctx.font = `bold ${fontSize}px arial`);
-        const filtered = data.filter((d: Annotation) => groupFilter.length <= 0 || groupFilter.includes(d.group));
-        const offset = calcSize(this.offsetFactor, this.offsetMin, this.offsetMax, xScale);
-        this.callouts = this.positionCallouts(filtered, isLeftToRight, xScale, yScale, scale, fontSize, offset);
+        const filtered = data.filter(
+          (d: Annotation) =>
+            groupFilter.length <= 0 || groupFilter.includes(d.group),
+        );
+        const offset = calcSize(
+          this.offsetFactor,
+          this.offsetMin,
+          this.offsetMax,
+          xScale,
+        );
+        this.callouts = this.positionCallouts(
+          filtered,
+          isLeftToRight,
+          xScale,
+          yScale,
+          scale,
+          fontSize,
+          offset,
+        );
       }
 
-      this.callouts.forEach((callout) => {
+      this.callouts.forEach(callout => {
         const { pos, title, color } = callout;
         const x = xScale(pos.x);
         const y = yScale(pos.y);
@@ -160,12 +196,24 @@ export class CalloutCanvasLayer<T extends Annotation[]> extends CanvasLayer<T> {
           offsetY: callout.dy,
         };
 
-        this.renderCallout(title, callout.label, calloutBB, color, callout.alignment);
+        this.renderCallout(
+          title,
+          callout.label,
+          calloutBB,
+          color,
+          callout.alignment,
+        );
       });
     });
   }
 
-  private renderBackground(title: string, label: string, x: number, y: number, fontSize: number): void {
+  private renderBackground(
+    title: string,
+    label: string,
+    x: number,
+    y: number,
+    fontSize: number,
+  ): void {
     const { ctx } = this;
 
     if (ctx == null) {
@@ -209,12 +257,27 @@ export class CalloutCanvasLayer<T extends Annotation[]> extends CanvasLayer<T> {
     }
   }
 
-  private renderAnnotation = (title: string, label: string, x: number, y: number, fontSize: number, color: string): void => {
+  private renderAnnotation = (
+    title: string,
+    label: string,
+    x: number,
+    y: number,
+    fontSize: number,
+    color: string,
+  ): void => {
     this.renderText(title, x, y - fontSize, fontSize, color, 'arial', 'bold');
     this.renderText(label, x, y, fontSize, color);
   };
 
-  private renderText(title: string, x: number, y: number, fontSize: number, color: string, font = 'arial', fontStyle = 'normal'): void {
+  private renderText(
+    title: string,
+    x: number,
+    y: number,
+    fontSize: number,
+    color: string,
+    font = 'arial',
+    fontStyle = 'normal',
+  ): void {
     const { ctx } = this;
     if (ctx != null) {
       ctx.font = `${fontStyle} ${fontSize}px ${font}`;
@@ -223,7 +286,12 @@ export class CalloutCanvasLayer<T extends Annotation[]> extends CanvasLayer<T> {
     }
   }
 
-  private measureTextWidth(title: string, fontSize: number, font = 'arial', fontStyle = 'normal'): number {
+  private measureTextWidth(
+    title: string,
+    fontSize: number,
+    font = 'arial',
+    fontStyle = 'normal',
+  ): number {
     const { ctx } = this;
 
     if (ctx == null) {
@@ -246,12 +314,19 @@ export class CalloutCanvasLayer<T extends Annotation[]> extends CanvasLayer<T> {
     }
   }
 
-  private renderCallout(title: string, label: string, boundingBox: BoundingBox, color: string, location: string): void {
+  private renderCallout(
+    title: string,
+    label: string,
+    boundingBox: BoundingBox,
+    color: string,
+    location: string,
+  ): void {
     const pos = this.getPosition(boundingBox, location);
     const { x, y } = pos;
     const { height, width, x: dotX, y: dotY } = boundingBox;
 
-    const placeLeft = location === Location.topright || location === Location.bottomright;
+    const placeLeft =
+      location === Location.topright || location === Location.bottomright;
 
     if (this.backgroundActive) {
       this.renderBackground(title, label, x, y, height);
@@ -262,7 +337,15 @@ export class CalloutCanvasLayer<T extends Annotation[]> extends CanvasLayer<T> {
     this.renderLine(x, y, width, dotX, dotY, color, placeLeft);
   }
 
-  private renderLine = (x: number, y: number, width: number, dotX: number, dotY: number, color: string, placeLeft = true): void => {
+  private renderLine = (
+    x: number,
+    y: number,
+    width: number,
+    dotX: number,
+    dotY: number,
+    color: string,
+    placeLeft = true,
+  ): void => {
     const { ctx } = this;
     const textX = placeLeft ? x : x + width;
     const inverseTextX = placeLeft ? x + width : x;
@@ -327,7 +410,7 @@ export class CalloutCanvasLayer<T extends Annotation[]> extends CanvasLayer<T> {
     }
     const alignment = isLeftToRight ? Location.topleft : Location.topright;
 
-    const nodes = annotations.map((a) => {
+    const nodes = annotations.map(a => {
       const pos = a.pos ? a.pos : this.referenceSystem?.project(a.md!)!;
       return {
         title: a.title,
@@ -336,7 +419,14 @@ export class CalloutCanvasLayer<T extends Annotation[]> extends CanvasLayer<T> {
         pos: { x: pos?.[0]!, y: pos?.[1]! },
         group: a.group,
         alignment,
-        boundingBox: this.getAnnotationBoundingBox(a.title, a.label, pos, xScale, yScale, fontSize),
+        boundingBox: this.getAnnotationBoundingBox(
+          a.title,
+          a.label,
+          pos,
+          xScale,
+          yScale,
+          fontSize,
+        ),
         dx: offset,
         dy: offset,
       };
@@ -382,14 +472,21 @@ export class CalloutCanvasLayer<T extends Annotation[]> extends CanvasLayer<T> {
     return bbox;
   }
 
-  chooseTopOrBottomPosition(nodes: Callout[], bottom: Callout[], top: Callout[]): void {
+  chooseTopOrBottomPosition(
+    nodes: Callout[],
+    bottom: Callout[],
+    top: Callout[],
+  ): void {
     for (let i = nodes.length - 2; i >= 0; --i) {
       const node = nodes[i]!;
       const prevNode = top[0]!;
 
       const overlap = isOverlapping(node.boundingBox, prevNode.boundingBox);
       if (overlap) {
-        node.alignment = node.alignment === Location.topleft ? Location.bottomright : Location.bottomleft;
+        node.alignment =
+          node.alignment === Location.topleft
+            ? Location.bottomright
+            : Location.bottomleft;
         bottom.push(node);
         if (i > 0) {
           top.unshift(nodes[--i]!);
@@ -405,7 +502,10 @@ export class CalloutCanvasLayer<T extends Annotation[]> extends CanvasLayer<T> {
       const currentNode = top[i]!;
       for (let j = top.length - 1; j > i; --j) {
         const prevNode = top[j]!;
-        const overlap = getOverlapOffset(currentNode.boundingBox, prevNode.boundingBox);
+        const overlap = getOverlapOffset(
+          currentNode.boundingBox,
+          prevNode.boundingBox,
+        );
         if (overlap) {
           currentNode.dy += overlap.dy;
           currentNode.boundingBox.y -= overlap.dy;
@@ -419,7 +519,10 @@ export class CalloutCanvasLayer<T extends Annotation[]> extends CanvasLayer<T> {
       const currentNode = bottom[i]!;
       for (let j = bottom.length - 1; j > i; --j) {
         const prevNode = bottom[j]!;
-        const overlap = getOverlapOffset(prevNode.boundingBox, currentNode.boundingBox);
+        const overlap = getOverlapOffset(
+          prevNode.boundingBox,
+          currentNode.boundingBox,
+        );
         if (overlap) {
           currentNode.dy += overlap.dy;
           currentNode.boundingBox.y += overlap.dy;

package/src/layers/CustomDisplayObjects/ComplexRope.ts

@@ -31,7 +31,8 @@ export class ComplexRope extends Mesh {
     this.autoUpdate = true;
 
     this.onRender = () => {
-      const geometry: ComplexRopeGeometry = this.geometry as ComplexRopeGeometry;
+      const geometry: ComplexRopeGeometry = this
+        .geometry as ComplexRopeGeometry;
 
       if (this.autoUpdate) {
         geometry.update();

package/src/layers/CustomDisplayObjects/ComplexRopeGeometry.ts

@@ -13,7 +13,7 @@ export class ComplexRopeGeometry extends MeshGeometry {
    * @param segments - An array of segments with points and diameter to construct this rope.
    */
   constructor(segments: ComplexRopeSegment[]) {
-    const pointCount = sum(segments, (segment) => segment.points.length);
+    const pointCount = sum(segments, segment => segment.points.length);
 
     super({
       positions: new Float32Array(pointCount * 4),
@@ -32,7 +32,7 @@ export class ComplexRopeGeometry extends MeshGeometry {
    * @readonly
    */
   get width(): number {
-    return max(this.segments, (segment) => segment.diameter)!;
+    return max(this.segments, segment => segment.diameter)!;
   }
 
   /** Refreshes Rope indices and uvs */
@@ -47,7 +47,7 @@ export class ComplexRopeGeometry extends MeshGeometry {
     const uvBuffer = this.getBuffer('aUV');
     const indexBuffer = this.getIndex();
 
-    const pointCount = sum(segments, (segment) => segment.points.length);
+    const pointCount = sum(segments, segment => segment.points.length);
 
     // if too few points, or texture hasn't got UVs set yet just move on.
     if (pointCount < 1) {
@@ -70,7 +70,7 @@ export class ComplexRopeGeometry extends MeshGeometry {
     uvs[3] = 1;
 
     const segmentCount = segments.length;
-    const maxDiameter = max(segments, (segment) => segment.diameter)!;
+    const maxDiameter = max(segments, segment => segment.diameter)!;
 
     let amount = 0;
     let uvIndex = 0;
@@ -126,7 +126,7 @@ export class ComplexRopeGeometry extends MeshGeometry {
   /** refreshes vertices of Rope mesh */
   public updateVertices(): void {
     const segments = this.segments;
-    const pointCount = sum(segments, (segment) => segment.points.length);
+    const pointCount = sum(segments, segment => segment.points.length);
 
     if (pointCount < 1) {
       return;

package/src/layers/CustomDisplayObjects/UniformTextureStretchRope.ts

@@ -16,14 +16,18 @@ export class UniformTextureStretchRope extends Mesh {
    * @param points - An array of {@link Point} objects to construct this rope.
    */
   constructor(texture: Texture, points: Point[]) {
-    const ropeGeometry = new UniformTextureStretchRopeGeometry(points, texture.height);
+    const ropeGeometry = new UniformTextureStretchRopeGeometry(
+      points,
+      texture.height,
+    );
 
     super({ geometry: ropeGeometry, texture });
 
     this.autoUpdate = true;
 
     this.onRender = () => {
-      const geometry: UniformTextureStretchRopeGeometry = this.geometry as UniformTextureStretchRopeGeometry;
+      const geometry: UniformTextureStretchRopeGeometry = this
+        .geometry as UniformTextureStretchRopeGeometry;
 
       if (this.autoUpdate || geometry._width !== this.shader?.texture.height) {
         geometry._width = this.shader?.texture.height ?? 0;

package/src/layers/GeomodelCanvasLayer.ts

@@ -59,8 +59,12 @@ export class GeomodelCanvasLayer<T extends SurfaceData> extends CanvasLayer<T> {
 
     requestAnimationFrame(() => {
       this.clearCanvas();
-      this.surfaceAreasPaths.forEach((p: SurfacePaths) => this.drawPolygonPath(p.color, p.path));
-      this.surfaceLinesPaths.forEach((l: SurfacePaths) => this.drawLinePath(l.color, l.path));
+      this.surfaceAreasPaths.forEach((p: SurfacePaths) =>
+        this.drawPolygonPath(p.color, p.path),
+      );
+      this.surfaceLinesPaths.forEach((l: SurfacePaths) =>
+        this.drawLinePath(l.color, l.path),
+      );
     });
   }
 
@@ -85,7 +89,10 @@ export class GeomodelCanvasLayer<T extends SurfaceData> extends CanvasLayer<T> {
     this.surfaceLinesPaths =
       this.data?.lines.reduce((acc: SurfacePaths[], l: SurfaceLine) => {
         const lines = this.generateLinePaths(l);
-        const mapped: SurfacePaths[] = lines.map((path: Path2D) => ({ color: this.colorToCSSColor(l.color), path }));
+        const mapped: SurfacePaths[] = lines.map((path: Path2D) => ({
+          color: this.colorToCSSColor(l.color),
+          path,
+        }));
         acc.push(...mapped);
         return acc;
       }, []) ?? [];