@equinor/esv-intersection 3.1.8 → 4.0.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,
@@ -124,7 +125,7 @@ export class DashLine {
   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;
   }
@@ -212,18 +213,18 @@ 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;
@@ -237,10 +238,10 @@ 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 +262,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);
@@ -281,21 +282,21 @@ export class DashLine {
       }
     } 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 +304,9 @@ 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 +345,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);
     }
@@ -357,7 +358,7 @@ export class DashLine {
   }
 
   // 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 +371,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 +384,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;
   }
 }