@equinor/esv-intersection 3.0.8 → 3.0.10

package/src/components/axis.ts

@@ -1,5 +1,5 @@
 import { axisRight, axisBottom } from 'd3-axis';
-import { BaseType, Selection } from 'd3-selection';
+import { Selection } from 'd3-selection';
 import { ScaleLinear, scaleLinear } from 'd3-scale';
 import { OnResizeEvent, OnRescaleEvent } from '../interfaces';
 
@@ -10,27 +10,20 @@ export type Options = {
 };
 
 export class Axis {
-  private mainGroup: Selection<SVGElement, unknown, null, undefined>;
+  private mainGroup: Selection<SVGSVGElement, unknown, null, undefined>;
   private _scaleX: ScaleLinear<number, number>;
   private _scaleY: ScaleLinear<number, number>;
   private _showLabels = true;
   private _labelXDesc: string;
   private _labelYDesc: string;
   private _unitOfMeasure: string;
-  private _offsetX: number = 0;
-  private _offsetY: number = 0;
+  private _offsetX = 0;
+  private _offsetY = 0;
   private _flipX = false;
   private _flipY = false;
-  private visible: boolean = true;
-
-  constructor(
-    mainGroup: Selection<SVGElement, unknown, null, undefined>,
-    showLabels = true,
-    labelXDesc: string,
-    labelYDesc: string,
-    unitOfMeasure: string,
-    options?: Options,
-  ) {
+  private visible = true;
+
+  constructor(mainGroup: Axis['mainGroup'], showLabels = true, labelXDesc: string, labelYDesc: string, unitOfMeasure: string, options?: Options) {
     this.mainGroup = mainGroup;
     this._showLabels = showLabels;
     this._labelXDesc = labelXDesc;
@@ -51,12 +44,12 @@ export class Axis {
     this._scaleY = scaleLinear().domain([0, 1]).range([0, 1]);
   }
 
-  private renderLabelx(): Selection<BaseType, unknown, null, undefined> {
+  private renderLabelx(): Selection<SVGTextElement, unknown, null, undefined> {
     const { _labelXDesc: labelXDesc, _unitOfMeasure: unitOfMeasure, _showLabels, _scaleX: scaleX } = this;
     const [, width] = scaleX.range();
     const gx = this.renderGx();
 
-    let labelx = gx.select('text.axis-labelx');
+    let labelx: Selection<SVGTextElement, unknown, null, undefined> = gx.select('text.axis-labelx');
     if (_showLabels) {
       if (labelx.empty()) {
         labelx = gx
@@ -71,16 +64,16 @@ export class Axis {
     } else {
       labelx.remove();
     }
-    labelx.attr('transform', `translate(${width / 2},-4)`);
+    labelx.attr('transform', `translate(${width! / 2},-4)`);
     return labelx;
   }
 
-  private renderLabely(): Selection<BaseType, unknown, null, undefined> {
+  private renderLabely(): Selection<SVGTextElement, unknown, null, undefined> {
     const { _labelYDesc: labelYDesc, _unitOfMeasure: unitOfMeasure, _showLabels, _scaleY } = this;
     const [, height] = _scaleY.range();
     const gy = this.renderGy();
 
-    let labely = gy.select('text.axis-labely');
+    let labely: Selection<SVGTextElement, unknown, null, undefined> = gy.select('text.axis-labely');
     if (_showLabels) {
       if (labely.empty()) {
         labely = gy
@@ -92,16 +85,16 @@ export class Axis {
           .style('font-size', '10px')
           .text(`${labelYDesc} (${unitOfMeasure})`);
       }
-      labely.attr('transform', `translate(-10,${height / 2})rotate(90)`);
+      labely.attr('transform', `translate(-10,${height! / 2})rotate(90)`);
     } else {
       labely.remove();
     }
     return labely;
   }
 
-  private renderGy(): Selection<BaseType, unknown, null, undefined> {
+  private renderGy(): Selection<SVGGElement, unknown, null, undefined> {
     const { _scaleX, _scaleY } = this;
-    const yAxis = axisRight(_scaleY) as (selection: Selection<SVGSVGElement, unknown, null, undefined>) => void;
+    const yAxis = axisRight(_scaleY) as (selection: Selection<SVGGElement, unknown, null, undefined>, ...args: any[]) => void;
     const [, width] = _scaleX.range();
     const gy = this.createOrGet('y-axis');
     gy.call(yAxis);
@@ -110,9 +103,9 @@ export class Axis {
     return gy;
   }
 
-  private renderGx(): Selection<BaseType, unknown, null, undefined> {
+  private renderGx(): Selection<SVGGElement, unknown, null, undefined> {
     const { _scaleX, _scaleY } = this;
-    const xAxis = axisBottom(_scaleX) as (selection: Selection<SVGSVGElement, unknown, null, undefined>) => void;
+    const xAxis = axisBottom(_scaleX) as (selection: Selection<SVGGElement, unknown, null, undefined>, ...args: any[]) => void;
     const [, height] = _scaleY.range();
 
     const gx = this.createOrGet('x-axis');
@@ -121,9 +114,9 @@ export class Axis {
     return gx;
   }
 
-  private createOrGet = (name: string): Selection<BaseType, unknown, null, undefined> => {
+  private createOrGet = (name: string): Selection<SVGGElement, unknown, null, undefined> => {
     const { mainGroup } = this;
-    let res = mainGroup.select(`g.${name}`);
+    let res: Selection<SVGGElement, unknown, null, undefined> = mainGroup.select(`g.${name}`);
     if (res.empty()) {
       res = mainGroup.append('g').attr('class', name);
     }
@@ -142,8 +135,8 @@ export class Axis {
   onRescale(event: OnRescaleEvent): void {
     const { _scaleX, _scaleY, offsetX, offsetY } = this;
     const { xScale, yScale } = event;
-    const xBounds = xScale.domain();
-    const yBounds = yScale.domain();
+    const xBounds = xScale.domain() as [number, number];
+    const yBounds = yScale.domain() as [number, number];
 
     const xRange = xScale.range();
     const yRange = yScale.range();
@@ -173,7 +166,7 @@ export class Axis {
 
   flipX(flipX: boolean): Axis {
     this._flipX = flipX;
-    const domain = this._scaleX.domain();
+    const domain = this._scaleX.domain() as [number, number];
     const flip = flipX ? -1 : 1;
     this._scaleX.domain([flip * domain[0], flip * domain[1]]);
     return this;
@@ -181,7 +174,7 @@ export class Axis {
 
   flipY(flipY: boolean): Axis {
     this._flipY = flipY;
-    const domain = this._scaleY.domain();
+    const domain = this._scaleY.domain() as [number, number];
     const flip = flipY ? -1 : 1;
     this._scaleY.domain([flip * domain[0], flip * domain[1]]);
     return this;

package/src/control/ExtendedCurveInterpolator.ts

@@ -78,13 +78,13 @@ export class ExtendedCurveInterpolator extends CurveInterpolator {
       this.generateArcLengthLookup();
     }
     const index = BinarySearch.search(this.arcLengthLookup, arcLength);
-    const v1 = this.arcLengthLookup[index];
-    const v2 = this.arcLengthLookup[index + 1];
+    const v1 = this.arcLengthLookup[index]!;
+    const v2 = this.arcLengthLookup[index + 1]!;
     const t = (index + (arcLength - v1) / (v2 - v1)) / this.arcLengthLookup.length;
     return t;
   }
 
-  generateArcLengthLookup(segments: number = 1000): void {
+  generateArcLengthLookup(segments = 1000): void {
     let lastPos = this.getPointAt(0);
     let length = 0;
     for (let i = 0; i < segments; i++) {
@@ -123,15 +123,15 @@ export class ExtendedCurveInterpolator extends CurveInterpolator {
 
     if (from !== 0) {
       const fromIndex = Math.floor(from * this.arcLengthLookup.length);
-      const fromLl = this.arcLengthLookup[fromIndex];
-      const fromLh = this.arcLengthLookup[fromIndex + 1];
+      const fromLl = this.arcLengthLookup[fromIndex]!;
+      const fromLh = this.arcLengthLookup[fromIndex + 1]!;
       fromLength = fromLl + ((from * this.arcLengthLookup.length) % this.arcLengthLookup.length) * (fromLh - fromLl);
     }
 
     if (to !== 1) {
       const toIndex = Math.floor(to * this.arcLengthLookup.length);
-      const toLl = this.arcLengthLookup[toIndex];
-      const toLh = this.arcLengthLookup[toIndex + 1];
+      const toLl = this.arcLengthLookup[toIndex]!;
+      const toLh = this.arcLengthLookup[toIndex + 1]!;
       toLength = toLl + ((from * this.arcLengthLookup.length) % this.arcLengthLookup.length) * (toLh - toLl);
     }
 

package/src/control/IntersectionReferenceSystem.ts

@@ -36,31 +36,23 @@ export interface ReferenceSystemOptions {
 }
 
 export class IntersectionReferenceSystem {
-  options: ReferenceSystemOptions;
+  options!: ReferenceSystemOptions;
 
   path: number[][] = [];
 
   projectedPath: number[][] = [];
 
-  projectedTrajectory: number[][];
+  private _offset = 0;
 
-  private _offset: number = 0;
+  displacement!: number;
 
-  displacement: number;
+  interpolators!: Interpolators;
 
-  depthReference: number;
+  startVector!: number[];
 
-  wellboreId: number;
+  endVector!: number[];
 
-  trajectoryOffset: number;
-
-  interpolators: Interpolators;
-
-  startVector: number[];
-
-  endVector: number[];
-
-  _curtainPathCache: MDPoint[];
+  _curtainPathCache: MDPoint[] | undefined;
 
   /**
    * Creates a common reference system that layers and other components can use
@@ -93,15 +85,15 @@ export class IntersectionReferenceSystem {
 
     this.projectedPath = IntersectionReferenceSystem.toDisplacement(path);
 
-    const [displacement] = this.projectedPath[this.projectedPath.length - 1];
-    this.displacement = displacement;
+    const [displacement] = this.projectedPath[this.projectedPath.length - 1]!;
+    this.displacement = displacement!;
 
     this.interpolators = {
       curve: options.curveInterpolator || new ExtendedCurveInterpolator(path),
       trajectory:
         options.trajectoryInterpolator ||
         new ExtendedCurveInterpolator(
-          path.map((d: number[]) => [d[0], d[1]]),
+          path.map((d: number[]) => [d[0]!, d[1]!]),
           { tension: tension || TENSION, arcDivisions: arcDivisions || ARC_DIVISIONS },
         ),
       curtain:
@@ -160,7 +152,7 @@ export class IntersectionReferenceSystem {
       let prevAngle = Math.PI * 2; // Always add first point
       for (let i = this._offset; i <= this.length + this._offset; i += CURTAIN_SAMPLING_INTERVAL) {
         const point = this.project(i);
-        const angle = Math.atan2(point[1], point[0]);
+        const angle = Math.atan2(point[1]!, point[0]!);
 
         // Reduce number of points on a straight line by angle since last point
         if (Math.abs(angle - prevAngle) > CURTAIN_SAMPLING_ANGLE_THRESHOLD) {
@@ -183,7 +175,7 @@ export class IntersectionReferenceSystem {
   /**
    * Map a displacement back to length along the curve
    */
-  unproject(displacement: number): number {
+  unproject(displacement: number): number | undefined {
     const { normalizedLength, calculateDisplacementFromBottom } = this.options;
     const displacementFromStart = calculateDisplacementFromBottom ? this.displacement - displacement : displacement;
     const length = normalizedLength || this.length;
@@ -197,9 +189,9 @@ export class IntersectionReferenceSystem {
 
     const ls = this.interpolators.curtain.getIntersectsAsPositions(displacementFromStart, 0, 1);
     if (ls && ls.length) {
-      return ls[0] * length + this._offset;
+      return ls[0]! * length + this._offset;
     }
-    return null;
+    return undefined;
   }
 
   /**
@@ -208,7 +200,7 @@ export class IntersectionReferenceSystem {
   getProjectedLength(length: number): number {
     const { curtain } = this.interpolators;
     const pl = this.project(length);
-    const l = pl[0] / curtain.maxX;
+    const l = pl[0]! / curtain.maxX;
     return Number.isFinite(l) ? clamp(l, 0, 1) : 0;
   }
 
@@ -229,21 +221,21 @@ export class IntersectionReferenceSystem {
     const extensionStart = from < 0 ? -from : 0;
     const extensionEnd = to > 1 ? to - 1 : 0;
 
-    const refStart = this.interpolators.trajectory.getPointAt(0) as number[];
-    const refEnd = this.interpolators.trajectory.getPointAt(1) as number[];
+    const refStart = this.interpolators.trajectory.getPointAt(0) as [number, number];
+    const refEnd = this.interpolators.trajectory.getPointAt(1) as [number, number];
 
-    let p0;
-    let p3;
+    let p0: [number, number];
+    let p3: [number, number];
     let offset = 0;
     const t0 = Math.max(0, from);
     const t1 = Math.min(1, to);
-    const p1 = this.interpolators.trajectory.getPointAt(t0) as number[];
-    const p2 = this.interpolators.trajectory.getPointAt(t1) as number[];
+    const p1 = this.interpolators.trajectory.getPointAt(t0) as [number, number];
+    const p2 = this.interpolators.trajectory.getPointAt(t1) as [number, number];
 
     if (extensionStart) {
       p0 = [
-        refStart[0] + this.startVector[0] * extensionStart * this.displacement,
-        refStart[1] + this.startVector[1] * extensionStart * this.displacement,
+        refStart[0] + this.startVector[0]! * extensionStart * this.displacement,
+        refStart[1] + this.startVector[1]! * extensionStart * this.displacement,
       ];
       offset = -Vector2.distance(p0, refStart);
     } else if (from > 0) {
@@ -251,7 +243,7 @@ export class IntersectionReferenceSystem {
     }
 
     if (extensionEnd) {
-      p3 = [refEnd[0] + this.endVector[0] * extensionEnd * this.displacement, refEnd[1] + this.endVector[1] * extensionEnd * this.displacement];
+      p3 = [refEnd[0] + this.endVector[0]! * extensionEnd * this.displacement, refEnd[1] + this.endVector[1]! * extensionEnd * this.displacement];
     }
     const points = [];
     const tl = to - from;
@@ -259,19 +251,19 @@ export class IntersectionReferenceSystem {
     const curveSteps = Math.ceil(((t1 - t0) / tl) * steps);
     const postSteps = steps - curveSteps - preSteps;
 
-    if (p0) {
+    if (p0!) {
       points.push(p0);
       for (let i = 1; i < preSteps; i++) {
         const f = (i / preSteps) * extensionStart * this.displacement;
-        points.push([p0[0] - this.startVector[0] * f, p0[1] - this.startVector[1] * f]);
+        points.push([p0[0] - this.startVector[0]! * f, p0[1] - this.startVector[1]! * f]);
       }
     }
     const curvePoints = this.interpolators.trajectory.getPoints(curveSteps - 1, null, t0, t1) as number[][]; // returns steps + 1 points
     points.push(...curvePoints);
-    if (p3) {
+    if (p3!) {
       for (let i = 1; i < postSteps - 1; i++) {
         const f = (i / postSteps) * extensionEnd * this.displacement;
-        points.push([p2[0] + this.endVector[0] * f, p2[1] + this.endVector[1] * f]);
+        points.push([p2[0] + this.endVector[0]! * f, p2[1] + this.endVector[1]! * f]);
       }
       points.push(p3);
     }
@@ -330,7 +322,7 @@ export class IntersectionReferenceSystem {
   getTrajectoryVector(): number[] {
     const { trajectoryAngle, calculateDisplacementFromBottom } = this.options;
 
-    if (isFinite(trajectoryAngle)) {
+    if (trajectoryAngle != null && isFinite(trajectoryAngle)) {
       const angleInRad = radians(trajectoryAngle);
       return new Vector2(Math.cos(angleInRad), Math.sin(angleInRad)).toArray();
     }
@@ -351,11 +343,11 @@ export class IntersectionReferenceSystem {
    * @returns {array}
    */
   static toDisplacement(points: number[][], offset = 0): number[][] {
-    let p0: number[] = points[0];
+    let p0: number[] = points[0]!;
     let l = 0;
     const projected = points.map((p1: number[]) => {
-      const dx = p1[0] - p0[0];
-      const dy = p1[1] - p0[1];
+      const dx = p1[0]! - p0[0]!;
+      const dy = p1[1]! - p0[1]!;
       l += Math.sqrt(dx ** 2 + dy ** 2);
       p0 = p1;
       return [offset > 0 ? offset - l : l, p1[2] || 0];
@@ -377,7 +369,7 @@ export class IntersectionReferenceSystem {
   }
 
   get length(): number {
-    return this.interpolators.curve.length;
+    return this.interpolators.curve?.length ?? 0;
   }
 
   get offset(): number {

package/src/control/LayerManager.ts

@@ -16,8 +16,8 @@ export class LayerManager {
 
   private layers: Layer<unknown>[] = [];
 
-  private _axis: Axis;
-  private _svgContainer: Selection<HTMLElement, unknown, null, undefined>;
+  private _axis: Axis | undefined;
+  private _svgContainer: Selection<HTMLDivElement, unknown, null, undefined> | undefined;
 
   /**
    * Handles layers and axis also holds a zoom and pan handler object
@@ -30,7 +30,7 @@ export class LayerManager {
     this.layerContainer = document.createElement('div');
     this.layerContainer.className = 'layer-container';
     this.container.appendChild(this.layerContainer);
-    this.adjustToSize(+this.container.getAttribute('width'), +this.container.getAttribute('height'));
+    this.adjustToSize(+(this.container.getAttribute('width') ?? 0), +(this.container.getAttribute('height') ?? 0));
     this._zoomPanHandler = new ZoomPanHandler(container, (event) => this.rescale(event));
     if (scaleOptions) {
       const { xMin, xMax, yMin, yMax, xBounds, yBounds } = scaleOptions;
@@ -71,7 +71,7 @@ export class LayerManager {
    * Clears data from all mounted layers
    * @param includeReferenceSystem - (optional) if true also removes reference system, default is true
    */
-  clearAllData(includeReferenceSystem: boolean = true): LayerManager {
+  clearAllData(includeReferenceSystem = true): LayerManager {
     this.layers.forEach((l) => l.clearData(includeReferenceSystem));
     return this;
   }
@@ -113,7 +113,7 @@ export class LayerManager {
     return this;
   }
 
-  getLayer(layerId: string): Layer<unknown> {
+  getLayer(layerId: string): Layer<unknown> | undefined {
     return this.layers.find((l) => l.id === layerId || l.getInternalLayerIds().includes(layerId));
   }
 
@@ -181,51 +181,57 @@ export class LayerManager {
   }
 
   showAxis(): LayerManager {
-    this._axis.show();
+    this._axis?.show();
     return this;
   }
 
   hideAxis(): LayerManager {
-    this._axis.hide();
+    this._axis?.hide();
     return this;
   }
 
   showAxisLabels(): LayerManager {
-    this._axis.showLabels();
+    this._axis?.showLabels();
     return this;
   }
 
   hideAxisLabels(): LayerManager {
-    this._axis.hideLabels();
+    this._axis?.hideLabels();
     return this;
   }
 
   setAxisOffset(x: number, y: number): LayerManager {
-    this._axis.offsetX = x;
-    this._axis.offsetY = y;
-    const gridLayers = this.layers.filter((l: Layer<unknown>) => l instanceof GridLayer<unknown>);
-    gridLayers.forEach((l: GridLayer<unknown>) => {
-      l.offsetX = x;
-      l.offsetY = y;
-    });
+    if (this._axis) {
+      this._axis.offsetX = x;
+      this._axis.offsetY = y;
+      const gridLayers = this.layers.filter((l: Layer<unknown>): l is GridLayer<unknown> => l instanceof GridLayer);
+      gridLayers.forEach((l: GridLayer<unknown>) => {
+        l.offsetX = x;
+        l.offsetY = y;
+      });
+    }
     return this;
   }
 
   setXAxisOffset(x: number): LayerManager {
-    this._axis.offsetX = x;
-    const gridLayers = this.layers.filter((l: Layer<unknown>) => l instanceof GridLayer<unknown>);
-    gridLayers.forEach((l: GridLayer<unknown>) => {
-      l.offsetX = x;
-    });
+    if (this._axis) {
+      this._axis.offsetX = x;
+      const gridLayers = this.layers.filter((l: Layer<unknown>): l is GridLayer<unknown> => l instanceof GridLayer);
+      gridLayers.forEach((l: GridLayer<unknown>) => {
+        l.offsetX = x;
+      });
+    }
     return this;
   }
 
   setYAxisOffset(y: number): LayerManager {
-    this._axis.offsetY = y;
-    const gridLayers = this.layers.filter((l: Layer<unknown>) => l instanceof GridLayer<unknown>);
-    gridLayers.forEach((l: GridLayer<unknown>) => {
-      l.offsetY = y;
-    });
+    if (this._axis) {
+      this._axis.offsetY = y;
+      const gridLayers = this.layers.filter((l: Layer<unknown>): l is GridLayer<unknown> => l instanceof GridLayer);
+      gridLayers.forEach((l: GridLayer<unknown>) => {
+        l.offsetY = y;
+      });
+    }
     return this;
   }
 
@@ -247,10 +253,6 @@ export class LayerManager {
   destroy(): LayerManager {
     this.removeAllLayers();
     this.layerContainer.remove();
-    this.layerContainer = undefined;
-    this.container = undefined;
-    this.layers = undefined;
-    this._zoomPanHandler = undefined;
     this._axis = undefined;
     this._svgContainer = undefined;
 
@@ -261,7 +263,7 @@ export class LayerManager {
     return this._zoomPanHandler;
   }
 
-  get axis(): Axis {
+  get axis(): Axis | undefined {
     return this._axis;
   }
 

package/src/control/MainController.ts

@@ -12,7 +12,7 @@ import { HORIZONTAL_AXIS_MARGIN, VERTICAL_AXIS_MARGIN } from '../constants';
  * API for controlling data and layers
  */
 export class Controller {
-  private _referenceSystem: IntersectionReferenceSystem;
+  private _referenceSystem: IntersectionReferenceSystem | undefined;
 
   private layerManager: LayerManager;
   private _overlay: Overlay<Controller>;
@@ -69,7 +69,7 @@ export class Controller {
    * Clears data from all mounted layers
    * @param includeReferenceSystem - (optional) if true also removes reference system, default is true
    */
-  clearAllData(includeReferenceSystem: boolean = true): Controller {
+  clearAllData(includeReferenceSystem = true): Controller {
     this.layerManager.clearAllData(includeReferenceSystem);
     return this;
   }
@@ -106,7 +106,7 @@ export class Controller {
    * Find first layer with given id, returns undefined if none are found
    * @param layerId string id
    */
-  getLayer(layerId: string): Layer<unknown> {
+  getLayer(layerId: string): Layer<unknown> | undefined {
     return this.layerManager.getLayer(layerId);
   }
 
@@ -259,8 +259,6 @@ export class Controller {
     this.layerManager.destroy();
     this._overlay.destroy();
     this._referenceSystem = undefined;
-    this.layerManager = undefined;
-    this._overlay = undefined;
     return this;
   }
 
@@ -278,7 +276,7 @@ export class Controller {
     return this._overlay;
   }
 
-  get referenceSystem(): IntersectionReferenceSystem {
+  get referenceSystem(): IntersectionReferenceSystem | undefined {
     return this._referenceSystem;
   }
 
@@ -286,7 +284,7 @@ export class Controller {
     return this.layerManager.zoomPanHandler;
   }
 
-  get axis(): Axis {
+  get axis(): Axis | undefined {
     return this.layerManager.axis;
   }