@equinor/esv-intersection 3.1.9 → 4.1.0

package/src/vendor/pixi-dashed-line/index.ts

@@ -1,3 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-nocheck
 // https://github.com/davidfig/pixi-dashed-line
 //
@@ -18,7 +19,7 @@
 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-import * as PIXI from 'pixi.js';
+import { Graphics, Matrix, Point, Texture, SCALE_MODES } from 'pixi.js';
 
 /** Define the dash: [dash length, gap size, dash size, gap size, ...] */
 export type Dashes = number[];
@@ -31,8 +32,8 @@ export interface DashLineOptions {
   scale?: number;
   useTexture?: boolean;
   useDots?: boolean;
-  cap?: PIXI.LINE_CAP;
-  join?: PIXI.LINE_JOIN;
+  cap?: LINE_CAP;
+  join?: LINE_JOIN;
   alignment?: number;
 }
 
@@ -47,18 +48,18 @@ const dashLineOptionsDefault: Partial<DashLineOptions> = {
 };
 
 export class DashLine {
-  graphics: PIXI.Graphics;
+  graphics: Graphics;
 
   /** current length of the line */
   lineLength: number;
 
   /** cursor location */
-  cursor = new PIXI.Point();
+  cursor = new Point();
 
   /** desired scale of line */
   scale = 1;
 
-  private start: PIXI.Point;
+  private start: Point;
 
   private dashSize: number;
   private dash: number[];
@@ -66,8 +67,8 @@ export class DashLine {
   private useTexture: boolean;
   private options: DashLineOptions;
 
-  // cache of PIXI.Textures for dashed lines
-  static dashTextureCache: Record<string, PIXI.Texture> = {};
+  // cache of Textures for dashed lines
+  static dashTextureCache: Record<string, Texture> = {};
 
   /**
    * Create a DashLine
@@ -78,11 +79,11 @@ export class DashLine {
    * @param [options.width=1] - width of the dashed line
    * @param [options.alpha=1] - alpha of the dashed line
    * @param [options.color=0xffffff] - color of the dashed line
-   * @param [options.cap] - add a PIXI.LINE_CAP style to dashed lines (only works for useTexture: false)
-   * @param [options.join] - add a PIXI.LINE_JOIN style to the dashed lines (only works for useTexture: false)
+   * @param [options.cap] - add a LINE_CAP style to dashed lines (only works for useTexture: false)
+   * @param [options.join] - add a LINE_JOIN style to the dashed lines (only works for useTexture: false)
    * @param [options.alignment] - The alignment of any lines drawn (0.5 = middle, 1 = outer, 0 = inner)
    */
-  constructor(graphics: PIXI.Graphics, options: DashLineOptions = {}) {
+  constructor(graphics: Graphics, options: DashLineOptions = {}) {
     this.graphics = graphics;
     options = { ...dashLineOptionsDefault, ...options };
     this.dash = options.dash;
@@ -105,7 +106,7 @@ export class DashLine {
         alignment: options.alignment,
       });
     } else {
-      this.graphics.lineStyle({
+      this.graphics.setStrokeStyle({
         width: options.width * options.scale,
         color: options.color,
         alpha: options.alpha,
@@ -117,14 +118,19 @@ export class DashLine {
     this.scale = options.scale;
   }
 
-  private static distance(x1: number, y1: number, x2: number, y2: number): number {
+  private static distance(
+    x1: number,
+    y1: number,
+    x2: number,
+    y2: number,
+  ): number {
     return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
   }
 
   moveTo(x: number, y: number): this {
     this.lineLength = 0;
     this.cursor.set(x, y);
-    this.start = new PIXI.Point(x, y);
+    this.start = new Point(x, y);
     this.graphics.moveTo(this.cursor.x, this.cursor.y);
     return this;
   }
@@ -142,7 +148,10 @@ export class DashLine {
       this.adjustLineStyle(angle);
       if (closed && this.dash.length % 2 === 0) {
         const gap = Math.min(this.dash[this.dash.length - 1], length);
-        this.graphics.lineTo(x - Math.cos(angle) * gap, y - Math.sin(angle) * gap);
+        this.graphics.lineTo(
+          x - Math.cos(angle) * gap,
+          y - Math.sin(angle) * gap,
+        );
         this.graphics.closePath();
       } else {
         this.graphics.lineTo(x, y);
@@ -176,10 +185,17 @@ export class DashLine {
         const dashSize = this.dash[dashIndex] * this.scale - dashStart;
         const dist = remaining > dashSize ? dashSize : remaining;
         if (closed) {
-          const remainingDistance = DashLine.distance(x0 + cos * dist, y0 + sin * dist, this.start.x, this.start.y);
+          const remainingDistance = DashLine.distance(
+            x0 + cos * dist,
+            y0 + sin * dist,
+            this.start.x,
+            this.start.y,
+          );
           if (remainingDistance <= dist) {
             if (dashIndex % 2 === 0) {
-              const lastDash = DashLine.distance(x0, y0, this.start.x, this.start.y) - this.dash[this.dash.length - 1] * this.scale;
+              const lastDash =
+                DashLine.distance(x0, y0, this.start.x, this.start.y) -
+                this.dash[this.dash.length - 1] * this.scale;
               x0 += cos * lastDash;
               y0 += sin * lastDash;
               this.graphics.lineTo(x0, y0);
@@ -212,23 +228,38 @@ export class DashLine {
     this.lineTo(this.start.x, this.start.y, true);
   }
 
-  drawCircle(x: number, y: number, radius: number, points = 80, matrix?: PIXI.Matrix): this {
+  drawCircle(
+    x: number,
+    y: number,
+    radius: number,
+    points = 80,
+    matrix?: Matrix,
+  ): this {
     const interval = (Math.PI * 2) / points;
     let angle = 0,
-      first: PIXI.Point;
+      first: Point;
     if (matrix) {
-      first = new PIXI.Point(x + Math.cos(angle) * radius, y + Math.sin(angle) * radius);
+      first = new Point(
+        x + Math.cos(angle) * radius,
+        y + Math.sin(angle) * radius,
+      );
       matrix.apply(first, first);
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-ignore
       this.moveTo(first[0], first[1]);
     } else {
-      first = new PIXI.Point(x + Math.cos(angle) * radius, y + Math.sin(angle) * radius);
+      first = new Point(
+        x + Math.cos(angle) * radius,
+        y + Math.sin(angle) * radius,
+      );
       this.moveTo(first.x, first.y);
     }
     angle += interval;
     for (let i = 1; i < points + 1; i++) {
-      const next = i === points ? first : [x + Math.cos(angle) * radius, y + Math.sin(angle) * radius];
+      const next =
+        i === points
+          ? first
+          : [x + Math.cos(angle) * radius, y + Math.sin(angle) * radius];
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-ignore
       this.lineTo(next[0], next[1]);
@@ -237,10 +268,17 @@ export class DashLine {
     return this;
   }
 
-  drawEllipse(x: number, y: number, radiusX: number, radiusY: number, points = 80, matrix?: PIXI.Matrix): this {
+  drawEllipse(
+    x: number,
+    y: number,
+    radiusX: number,
+    radiusY: number,
+    points = 80,
+    matrix?: Matrix,
+  ): this {
     const interval = (Math.PI * 2) / points;
     let first: { x: number; y: number };
-    const point = new PIXI.Point();
+    const point = new Point();
     for (let i = 0; i < Math.PI * 2; i += interval) {
       let x0 = x - radiusX * Math.sin(i);
       let y0 = y - radiusY * Math.cos(i);
@@ -261,8 +299,8 @@ export class DashLine {
     return this;
   }
 
-  drawPolygon(points: PIXI.Point[] | number[], matrix?: PIXI.Matrix): this {
-    const p = new PIXI.Point();
+  drawPolygon(points: Point[] | number[], matrix?: Matrix): this {
+    const p = new Point();
     if (typeof points[0] === 'number') {
       if (matrix) {
         p.set(points[0] as number, points[1] as number);
@@ -276,26 +314,30 @@ export class DashLine {
       } else {
         this.moveTo(points[0] as number, points[1] as number);
         for (let i = 2; i < points.length; i += 2) {
-          this.lineTo(points[i] as number, points[i + 1] as number, i === points.length - 2);
+          this.lineTo(
+            points[i] as number,
+            points[i + 1] as number,
+            i === points.length - 2,
+          );
         }
       }
     } else {
       if (matrix) {
-        const point = points[0] as PIXI.Point;
+        const point = points[0] as Point;
         p.copyFrom(point);
         matrix.apply(p, p);
         this.moveTo(p.x, p.y);
         for (let i = 1; i < points.length; i++) {
-          const point = points[i] as PIXI.Point;
+          const point = points[i] as Point;
           p.copyFrom(point);
           matrix.apply(p, p);
           this.lineTo(p.x, p.y, i === points.length - 1);
         }
       } else {
-        const point = points[0] as PIXI.Point;
+        const point = points[0] as Point;
         this.moveTo(point.x, point.y);
         for (let i = 1; i < points.length; i++) {
-          const point = points[i] as PIXI.Point;
+          const point = points[i] as Point;
           this.lineTo(point.x, point.y, i === points.length - 1);
         }
       }
@@ -303,9 +345,15 @@ export class DashLine {
     return this;
   }
 
-  drawRect(x: number, y: number, width: number, height: number, matrix?: PIXI.Matrix): this {
+  drawRect(
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    matrix?: Matrix,
+  ): this {
     if (matrix) {
-      const p = new PIXI.Point();
+      const p = new Point();
 
       // moveTo(x, y)
       p.set(x, y);
@@ -344,7 +392,7 @@ export class DashLine {
   // adjust the matrix for the dashed texture
   private adjustLineStyle(angle: number) {
     const lineStyle = this.graphics.line;
-    lineStyle.matrix = new PIXI.Matrix();
+    lineStyle.matrix = new Matrix();
     if (angle) {
       lineStyle.matrix.rotate(angle);
     }
@@ -352,12 +400,18 @@ export class DashLine {
       lineStyle.matrix.scale(this.scale, this.scale);
     }
     const textureStart = -this.lineLength;
-    lineStyle.matrix.translate(this.cursor.x + textureStart * Math.cos(angle), this.cursor.y + textureStart * Math.sin(angle));
+    lineStyle.matrix.translate(
+      this.cursor.x + textureStart * Math.cos(angle),
+      this.cursor.y + textureStart * Math.sin(angle),
+    );
     this.graphics.lineStyle(lineStyle);
   }
 
   // creates or uses cached texture
-  private static getTexture(options: DashLineOptions, dashSize: number): PIXI.Texture | undefined {
+  private static getTexture(
+    options: DashLineOptions,
+    dashSize: number,
+  ): Texture | undefined {
     const key = options.dash.toString();
     if (DashLine.dashTextureCache[key]) {
       return DashLine.dashTextureCache[key];
@@ -370,7 +424,6 @@ export class DashLine {
       console.warn('Did not get context from canvas');
       return undefined;
     }
-    context.strokeStyle = 'white';
     context.globalAlpha = options.alpha;
     context.lineWidth = options.width;
     let x = 0;
@@ -384,9 +437,10 @@ export class DashLine {
         context.moveTo(x, y);
       }
     }
+    context.strokeStyle = 'white';
     context.stroke();
-    const texture = (DashLine.dashTextureCache[key] = PIXI.Texture.from(canvas));
-    texture.baseTexture.scaleMode = PIXI.SCALE_MODES.NEAREST;
+    const texture = (DashLine.dashTextureCache[key] = Texture.from(canvas));
+    texture.baseTexture.scaleMode = SCALE_MODES.NEAREST;
     return texture;
   }
 }