plotboilerplate 1.23.2 → 1.23.3

package/src/ts/utils/algorithms/findPolygonSelfIntersections.ts

@@ -5,6 +5,7 @@
  * @author   Ikaros Kappler
  * @date     2020-12-04
  * @modified 2020-12-09 Ported from vanilla JS to Typescript.
+ * @modified 2024-11-22 Fixed a type error in line 41.
  */
 
 import { Line } from "../../Line";
@@ -18,34 +19,32 @@ import { XYCoords } from "../../interfaces";
  *
  * @name findPolygonSelfIntersections
  * @param {Array<Vertex>} vertices - The vertices that form the polygon.
- * @return Array<Vertex>
+ * @return {Array<Vertex>}
  */
-export const findPolygonSelfIntersections = ( vertices:Array<XYCoords> ) : Array<Vertex> => {
-    const pointList : Array<Vertex> = [];
-    const lineA : Line = new Line( new Vertex(), new Vertex() );
-    const lineB : Line = new Line( new Vertex(), new Vertex() );
-    const n : number = vertices.length;
-    for( var a = 0; a < n; a++ ) {
-	lineA.a.set( vertices[a] );
-	lineA.b.set( vertices[(a+1)%n] );
-	for( var b = 0; b < n; b++ ) {
-	    // Same edge or neighbour edges intersect by definition.
-	    // Skip them.
-	    if( a == b || a+1 == b || a == b+1 || (a==0&&b+1==n) || (b==0&&a+1==n) )
-		continue;
-	    lineB.a.set( vertices[b] );
-	    lineB.b.set( vertices[(b+1)%n] );
+export const findPolygonSelfIntersections = (vertices: Array<XYCoords>): Array<Vertex> => {
+  const pointList: Array<Vertex> = [];
+  const lineA: Line = new Line(new Vertex(), new Vertex());
+  const lineB: Line = new Line(new Vertex(), new Vertex());
+  const n: number = vertices.length;
+  for (var a = 0; a < n; a++) {
+    lineA.a.set(vertices[a]);
+    lineA.b.set(vertices[(a + 1) % n]);
+    for (var b = 0; b < n; b++) {
+      // Same edge or neighbour edges intersect by definition.
+      // Skip them.
+      if (a == b || a + 1 == b || a == b + 1 || (a == 0 && b + 1 == n) || (b == 0 && a + 1 == n)) continue;
+      lineB.a.set(vertices[b]);
+      lineB.b.set(vertices[(b + 1) % n]);
 
-	    // Commpute the intersection point of the (infinite) lines.
-	    // The point is undefined if and only if both line are parallel (co-linear).
-	    const intersectionPoint : Vertex|undefined = lineA.intersection(lineB);
+      // Commpute the intersection point of the (infinite) lines.
+      // The point is undefined if and only if both line are parallel (co-linear).
+      const intersectionPoint: Vertex | null = lineA.intersection(lineB);
 
-	    // Check if the intersection point is on both (finite) edges of the polygon.
-	    if( intersectionPoint
-		&& lineA.hasPoint(intersectionPoint) && lineB.hasPoint(intersectionPoint) ) {
-		pointList.push( intersectionPoint );
-	    }
-	}	
+      // Check if the intersection point is on both (finite) edges of the polygon.
+      if (intersectionPoint && lineA.hasPoint(intersectionPoint) && lineB.hasPoint(intersectionPoint)) {
+        pointList.push(intersectionPoint);
+      }
     }
-    return pointList;
+  }
+  return pointList;
 };

package/src/ts/utils/algorithms/splitPolygonToNonIntersecting.ts

@@ -1,25 +1,24 @@
 /**
  * @requires Line
  * @requires Vertex
- * 
+ *
  * @author   Ikaros Kappler
  * @date     2020-12-04
  * @modified 2020-12-07 Ported from vanilla JS to typescript.
- * @version  1.0.1
+ * @modified 2024-11-22 Added the `insideBoundsOnly` param to the `splitPolygonToNonIntersecting` algorithm.
+ * @version  1.1.0
  */
 
 import { Line } from "../../Line";
 import { Vertex } from "../../Vertex";
 
-
 /**
  * Splitting a polygon at a self intersection results in two new polygons.
  */
-type ISplit = [ Array<Vertex>, Array<Vertex> ];
-
+type ISplit = [Array<Vertex>, Array<Vertex>];
 
 /**
- * This function cuts a given self-intersecting polygon into non-self-intersecting 
+ * This function cuts a given self-intersecting polygon into non-self-intersecting
  * sub polygons.
  *
  * The algorithm only works for non-self-overlapping polygons:
@@ -35,97 +34,91 @@ type ISplit = [ Array<Vertex>, Array<Vertex> ];
  * @return {Array<Array<Vertex>>} A sequence of non-self-intersecting sub polygons.
  */
 export const splitPolygonToNonIntersecting = (() => {
-
-    /**
-     * @param {Array<Vertex>} vertices
-     * @param {number=10} maxDepth
-     */  
-    const splitPolygonToNonIntersecting = ( vertices:Array<Vertex>,
-					    maxDepth?:number ) : Array<Array<Vertex>> => {
-	if( typeof maxDepth === "undefined" )
-	    maxDepth = 10;
-	return _splitPolygonToNonIntersecting( vertices, maxDepth );
-    };
-
-    
-    const _splitPolygonToNonIntersecting = ( vertices:Array<Vertex>,
-					     maxDepth:number ) : Array<Array<Vertex>> =>  {
-	if( maxDepth <= 0 ) {
-	    // aborting at max depth
-	    return [ vertices ];
-	}
-
-	if( vertices.length <= 3 ) {
-	    // No intersections possible
-	    return [ vertices ];
-	}
-
-	const n : number= vertices.length;
-	const lineA : Line = new Line( new Vertex(), new Vertex() );
-	const lineB : Line = new Line( new Vertex(), new Vertex() );
-	for( var a = 0; a < vertices.length; a++ ) {
-	    lineA.a.set( vertices[a] );
-	    lineA.b.set( vertices[(a+1) % n] );
-	    for( var b = 0; b < vertices.length; b++ ) {
-		// Equal edges or neighbour edges intersect by definition.
-		// We ignore them.
-		if( a == b || a+1 == b || a == b+1
-		    || (a==0&&b+1==vertices.length) || (b==0&&a+1==vertices.length) )
-		    continue;
-		lineB.a.set( vertices[b] );
-		lineB.b.set( vertices[(b+1) % n] );
-
-		const intersectionPoint : Vertex|undefined = lineA.intersection(lineB);
-		if( intersectionPoint && lineA.hasPoint(intersectionPoint) && lineB.hasPoint(intersectionPoint) ) {
-
-		    // Cut polygon into two here
-		    const split : ISplit = splitPolygonAt( vertices, a, b, intersectionPoint );
-		    
-		    // Split has 2 elements.
-		    const leftCleaned : Array<Array<Vertex>> =
-			_splitPolygonToNonIntersecting( split[0], maxDepth-1 );
-		    const rightCleaned : Array<Array<Vertex>> =
-			_splitPolygonToNonIntersecting( split[1], maxDepth-1 );
-
-		    return leftCleaned.concat( rightCleaned );
-		}
-	    }	
-	}
-
-	// No intersection found:
-	//    just return a list with the original
-	//    polygon as its only element.
-	return [ vertices ];
-    };
-
-
-    // Pre: edgeIndexA < edgeIndexB && vertices.length >= 4
-    const splitPolygonAt = ( vertices:Array<Vertex>,
-			     edgeIndexA:number,
-			     edgeIndexB:number,
-			     intersectionPoint:Vertex ) : ISplit => {
-	const first : Array<Vertex> = [];
-	var second : Array<Vertex> = [];
-	for( var i = 0; i < vertices.length; i++ ) {
-	    if( i <= edgeIndexA )
-		first.push( vertices[i] );
-
-	    if( i == edgeIndexA )  {
-		first.push( intersectionPoint );
-		second.push( intersectionPoint ); // clone???
-	    }
-
-	    if( i > edgeIndexA && i <= edgeIndexB )
-		second.push( vertices[i] );
-
-	    if( i > edgeIndexB )
-		first.push( vertices[i] );
-	    
-	}
-
-	return [ first, second ];
-    };
-
-    return splitPolygonToNonIntersecting;
+  /**
+   * @param {Array<Vertex>} vertices
+   * @param {number=10} maxDepth
+   */
+  const splitPolygonToNonIntersecting = (
+    vertices: Array<Vertex>,
+    maxDepth?: number,
+    insideBoundsOnly?: boolean
+  ): Array<Array<Vertex>> => {
+    if (typeof maxDepth === "undefined") maxDepth = 10;
+    return _splitPolygonToNonIntersecting(vertices, maxDepth, insideBoundsOnly);
+  };
+
+  const _splitPolygonToNonIntersecting = (
+    vertices: Array<Vertex>,
+    maxDepth: number,
+    insideBoundsOnly?: boolean
+  ): Array<Array<Vertex>> => {
+    if (maxDepth <= 0) {
+      // aborting at max depth
+      return [vertices];
+    }
+
+    if (vertices.length <= 3) {
+      // No intersections possible
+      return [vertices];
+    }
+
+    const n: number = vertices.length;
+    const lineA: Line = new Line(new Vertex(), new Vertex());
+    const lineB: Line = new Line(new Vertex(), new Vertex());
+    for (var a = 0; a < vertices.length; a++) {
+      lineA.a.set(vertices[a]);
+      lineA.b.set(vertices[(a + 1) % n]);
+      for (var b = 0; b < vertices.length; b++) {
+        // Equal edges or neighbour edges intersect by definition.
+        // We ignore them.
+        if (a == b || a + 1 == b || a == b + 1 || (a == 0 && b + 1 == vertices.length) || (b == 0 && a + 1 == vertices.length))
+          continue;
+        lineB.a.set(vertices[b]);
+        lineB.b.set(vertices[(b + 1) % n]);
+
+        const intersectionPoint: Vertex | null = lineA.intersection(lineB);
+        if (
+          intersectionPoint &&
+          lineA.hasPoint(intersectionPoint, insideBoundsOnly) &&
+          lineB.hasPoint(intersectionPoint, insideBoundsOnly)
+        ) {
+          // Cut polygon into two here
+          const split: ISplit = splitPolygonAt(vertices, a, b, intersectionPoint);
+
+          // Split has 2 elements.
+          const leftCleaned: Array<Array<Vertex>> = _splitPolygonToNonIntersecting(split[0], maxDepth - 1, insideBoundsOnly);
+          const rightCleaned: Array<Array<Vertex>> = _splitPolygonToNonIntersecting(split[1], maxDepth - 1, insideBoundsOnly);
+
+          return leftCleaned.concat(rightCleaned);
+        }
+      }
+    }
+
+    // No intersection found:
+    //    just return a list with the original
+    //    polygon as its only element.
+    return [vertices];
+  };
+
+  // Pre: edgeIndexA < edgeIndexB && vertices.length >= 4
+  const splitPolygonAt = (vertices: Array<Vertex>, edgeIndexA: number, edgeIndexB: number, intersectionPoint: Vertex): ISplit => {
+    const first: Array<Vertex> = [];
+    var second: Array<Vertex> = [];
+    for (var i = 0; i < vertices.length; i++) {
+      if (i <= edgeIndexA) first.push(vertices[i]);
+
+      if (i == edgeIndexA) {
+        first.push(intersectionPoint);
+        second.push(intersectionPoint); // clone???
+      }
+
+      if (i > edgeIndexA && i <= edgeIndexB) second.push(vertices[i]);
+
+      if (i > edgeIndexB) first.push(vertices[i]);
+    }
+
+    return [first, second];
+  };
+
+  return splitPolygonToNonIntersecting;
 })();
-

package/src/ts/utils/detectDarkMode.ts

@@ -8,9 +8,7 @@
  * @returns {boolean}
  */
 
-import PlotBoilerplate from "../PlotBoilerplate";
-
-export const detectDarkMode = (GUP?: Record<string, string>) => {
+export const detectDarkMode = (GUP?: Record<string, string>): boolean => {
   // Respect overrides
   if (typeof GUP !== "undefined" && GUP.hasOwnProperty("darkmode") && GUP["darkmode"]) {
     // const overrideValue = PlotBoilerplate.utils.fetch.bool(GUP, "darkmode", null);

package/src/ts/utils/dom/guiSizeToggler.ts

@@ -5,7 +5,8 @@
  * @date     2021-12-13
  * @modified 2022-01-10
  * @modified 2024-06-25 Ported to typescript and moved to utils/dom (was located inside demos before).
- * @version  1.1.0
+ * @modified 2024-10-02 Added a transition time.
+ * @version  1.1.1
  */
 
 import { GUI } from "../../interfaces/externals";
@@ -36,7 +37,8 @@ const applyGuiSize = (gui: GUI, guiDoubleSize: boolean, cssProps: Record<string,
   }
 };
 
-export const guiSizeToggler /* gst */ = (gui: GUI, config: ITogglerConfig, cssProps: Record<string, string>) => {
+export const guiSizeToggler = (gui: GUI, config: ITogglerConfig, cssProps: Record<string, string>) => {
+  gui.domElement.style["transition"] = "transform 0.5s";
   return {
     update: function () {
       applyGuiSize(gui, Boolean(config.guiDoubleSize), cssProps);