plotboilerplate 1.21.0 → 1.23.0

package/src/ts/utils/helpers/CircleSectorHelper.ts

@@ -14,12 +14,13 @@
  * @author   Ikaros Kappler
  * @date     2021-01-22
  * @modified 2021-01-26 Moving control points with center points
- * @version  1.0.1
+ * @modified 2024-03-10 Adding the `destory` method for properly removing installed listeners.
+ * @version  1.1.0
  **/
 
 import { CircleSector } from "../../CircleSector";
 import { PlotBoilerplate } from "../../PlotBoilerplate";
-import { VertEvent } from "../../VertexListeners";
+import { VertEvent, VertListener } from "../../VertexListeners";
 import { Vertex } from "../../Vertex";
 
 
@@ -28,6 +29,14 @@ import { Vertex } from "../../Vertex";
  */
 export class CircleSectorHelper {
 
+	private circleSector: CircleSector;
+	private controlPointStart: Vertex;
+	private controlPointEnd: Vertex;
+
+	private centerListener: VertListener;
+	private radiusStartListener : VertListener;
+	private radiusEndListener : VertListener;
+
     /**
      * The constructor.
      *
@@ -44,24 +53,99 @@ export class CircleSectorHelper {
 		 pb:PlotBoilerplate
 	       ) {
 
-	circleSector.circle.center.listeners.addDragListener( (e:VertEvent) => {
-	    controlPointStart.add( e.params.dragAmount );
-	    controlPointEnd.add( e.params.dragAmount );
-	} );
+			this.circleSector = circleSector;
+			this.controlPointStart = controlPointStart;
+			this.controlPointEnd = controlPointEnd;
+
+			this.circleSector.circle.center.listeners.addDragListener( this.centerListener = this._handleDragCenter() );
+			this.controlPointStart.listeners.addDragListener( this.radiusStartListener = this._handleDragStartControlPoint() );
+			this.controlPointEnd.listeners.addDragListener( this.radiusEndListener = this._handleDragEndControlPoint() );
+	// circleSector.circle.center.listeners.addDragListener( (e:VertEvent) => {
+	//     controlPointStart.add( e.params.dragAmount );
+	//     controlPointEnd.add( e.params.dragAmount );
+	// } );
 	
-	controlPointStart.listeners.addDragListener( (e:VertEvent) => {
-	    circleSector.circle.radius = circleSector.circle.center.distance(controlPointStart);
-	    controlPointEnd.set( circleSector.circle.vertAt(circleSector.endAngle) );
-	    circleSector.startAngle = circleSector.circle.center.angle( controlPointStart );
-	} );
-
-	controlPointEnd.listeners.addDragListener( (e:VertEvent) => {
-	    circleSector.circle.radius = circleSector.circle.center.distance(controlPointEnd);
-	    controlPointStart.set( circleSector.circle.vertAt(circleSector.startAngle) );
-	    circleSector.endAngle = circleSector.circle.center.angle( controlPointEnd );
-	} );
+	// controlPointStart.listeners.addDragListener( (e:VertEvent) => {
+	//     circleSector.circle.radius = circleSector.circle.center.distance(controlPointStart);
+	//     controlPointEnd.set( circleSector.circle.vertAt(circleSector.endAngle) );
+	//     circleSector.startAngle = circleSector.circle.center.angle( controlPointStart );
+	// } );
+
+	// controlPointEnd.listeners.addDragListener( (e:VertEvent) => {
+	//     circleSector.circle.radius = circleSector.circle.center.distance(controlPointEnd);
+	//     controlPointStart.set( circleSector.circle.vertAt(circleSector.startAngle) );
+	//     circleSector.endAngle = circleSector.circle.center.angle( controlPointEnd );
+	// } );
 	
     }
+
+	/**
+	 * Creates a new drag handler for the circle sector's center point.
+	 *
+	 * @private
+	 * @method handleDragCenter
+	 * @instance
+	 * @memberof CircleSectorHelper
+	 * @returns A new event handler.
+	 */
+	private _handleDragCenter() : VertListener {
+		const _self = this;
+		return (e:VertEvent) => {
+			_self.controlPointStart.add( e.params.dragAmount );
+			_self.controlPointEnd.add( e.params.dragAmount );
+		} ;
+	}
+	
+	/**
+	 * Creates a new drag handler for the circle sector's start control point.
+	 *
+	 * @private
+	 * @method _handleDragStartControlPoint
+	 * @instance
+	 * @memberof CircleSectorHelper
+	 * @returns A new event handler.
+	 */
+	private _handleDragStartControlPoint() : VertListener{
+		const _self = this;
+		return (e:VertEvent) => {
+			_self.circleSector.circle.radius = _self.circleSector.circle.center.distance(_self.controlPointStart);
+			_self.controlPointEnd.set( _self.circleSector.circle.vertAt(_self.circleSector.endAngle) );
+			_self.circleSector.startAngle = _self.circleSector.circle.center.angle( _self.controlPointStart );
+		} 
+	};
+
+	/**
+	 * Creates a new drag handler for the circle sector's end control point.
+	 *
+	 * @private
+	 * @method _handleDragEndControlPoint
+	 * @instance
+	 * @memberof CircleSectorHelper
+	 * @returns A new event handler.
+	 */
+	private _handleDragEndControlPoint() : VertListener {
+		const _self = this;
+		return (e:VertEvent) => {
+			_self.circleSector.circle.radius = _self.circleSector.circle.center.distance(_self.controlPointEnd);
+	    	_self.controlPointStart.set( _self.circleSector.circle.vertAt(_self.circleSector.startAngle) );
+	    	_self.circleSector.endAngle = _self.circleSector.circle.center.angle( _self.controlPointEnd );
+		} 
+	};
+
+  	/**
+	 * Destroy this circle helper.
+	 * The listeners will be removed from the circle sector's points.
+	 *
+	 * @method destroy
+	 * @instance
+	 * @memberof CircleSectorHelper
+	 */
+	public destroy() : void {
+		this.circleSector.circle.center.listeners.removeDragListener( this.centerListener );
+		this.controlPointStart.listeners.removeDragListener( this.radiusStartListener );
+		this.controlPointEnd.listeners.removeDragListener( this.radiusEndListener );
+	}
+
 };
 
 

package/src/ts/utils/parsers/STLParser.ts

@@ -6,8 +6,9 @@
  *
  * Refactored by Ikaros Kappler
  *
- * @date 2021-04-16
- * @version 0.0.1
+ * @date     2021-04-16
+ * @modified 2024-03-09 Added type checks for Typescript 5 compatibility.
+ * @version  0.0.2
  */
 
 /**
@@ -30,9 +31,9 @@ class Vertex {
 
 // Vertex Holder
 class VertexHolder {
-  vert1: Vert3;
-  vert2: Vert3;
-  vert3: Vert3;
+  vert1: Vert3 | undefined;
+  vert2: Vert3 | undefined;
+  vert3: Vert3 | undefined;
   constructor(vertex1?: Vertex, vertex2?: Vertex, vertex3?: Vertex) {
     this.vert1 = vertex1;
     this.vert2 = vertex2;
@@ -81,19 +82,41 @@ export class STLParser {
       /facet\s+normal\s+([-+]?\b(?:[0-9]*\.)?[0-9]+(?:[eE][-+]?[0-9]+)?\b)\s+([-+]?\b(?:[0-9]*\.)?[0-9]+(?:[eE][-+]?[0-9]+)?\b)\s+([-+]?\b(?:[0-9]*\.)?[0-9]+(?:[eE][-+]?[0-9]+)?\b)\s+outer\s+loop\s+vertex\s+([-+]?\b(?:[0-9]*\.)?[0-9]+(?:[eE][-+]?[0-9]+)?\b)\s+([-+]?\b(?:[0-9]*\.)?[0-9]+(?:[eE][-+]?[0-9]+)?\b)\s+([-+]?\b(?:[0-9]*\.)?[0-9]+(?:[eE][-+]?[0-9]+)?\b)\s+vertex\s+([-+]?\b(?:[0-9]*\.)?[0-9]+(?:[eE][-+]?[0-9]+)?\b)\s+([-+]?\b(?:[0-9]*\.)?[0-9]+(?:[eE][-+]?[0-9]+)?\b)\s+([-+]?\b(?:[0-9]*\.)?[0-9]+(?:[eE][-+]?[0-9]+)?\b)\s+vertex\s+([-+]?\b(?:[0-9]*\.)?[0-9]+(?:[eE][-+]?[0-9]+)?\b)\s+([-+]?\b(?:[0-9]*\.)?[0-9]+(?:[eE][-+]?[0-9]+)?\b)\s+([-+]?\b(?:[0-9]*\.)?[0-9]+(?:[eE][-+]?[0-9]+)?\b)\s+endloop\s+endfacet/g
     );
 
+    if( !vertexes ) {
+      throw "[STLParser] Failed to parse STL input; regex could not match."
+    };
+
     const _handleFacet: FacetHandler = this.handleFacet;
-    vertexes.forEach(function (vert) {
+    vertexes.forEach( (vert:string) => {
       const preVertexHolder = new VertexHolder();
-      vert
+      const vertValues = vert
         .match(
           /vertex\s+([-+]?\b(?:[0-9]*\.)?[0-9]+(?:[eE][-+]?[0-9]+)?\b)\s+([-+]?\b(?:[0-9]*\.)?[0-9]+(?:[eE][-+]?[0-9]+)?\b)\s+([-+]?\b(?:[0-9]*\.)?[0-9]+(?:[eE][-+]?[0-9]+)?\b)\s/g
-        )
-        .forEach(function (vertex, i) {
-          var tempVertex = vertex.replace("vertex", "").match(/[-+]?[0-9]*\.?[0-9]+/g);
-          var preVertex = new Vertex(Number(tempVertex[0]), Number(tempVertex[1]), Number(tempVertex[2]));
-          preVertexHolder["vert" + (i + 1)] = preVertex;
-        });
-      _handleFacet(preVertexHolder.vert1, preVertexHolder.vert2, preVertexHolder.vert3);
+        );
+        if( !vertValues ) {
+          console.warn("[STLParser] Could not parse vertex values.", vertValues);
+        } else {
+          vertValues.forEach( (vertex:string, i:number) => {
+            const tempVertex = vertex.replace("vertex", "").match(/[-+]?[0-9]*\.?[0-9]+/g);
+            if( !tempVertex ) {
+              console.warn("[STLParser] Failed to parse vertex value.", tempVertex);
+            } else {
+              const preVertex = new Vertex(Number(tempVertex[0]), Number(tempVertex[1]), Number(tempVertex[2]));
+              // preVertexHolder["vert" + (i + 1)] = preVertex;
+              switch( i ) {
+                case 0: preVertexHolder.vert1 = preVertex; break;
+                case 1: preVertexHolder.vert2 = preVertex; break;
+                case 2: preVertexHolder.vert3 = preVertex; break;
+                default: console.warn("[STLParse] Warning, vertex component index unexpeced.", i);
+              }
+            }
+          });
+        }
+        if( preVertexHolder.vert1 && preVertexHolder.vert2 && preVertexHolder.vert3) {
+          _handleFacet(preVertexHolder.vert1, preVertexHolder.vert2, preVertexHolder.vert3);
+        } else {
+          console.warn("[STLParse] Warning, cannot add vertex to mesh. vertex not fully defined.");
+        }
     });
   }
 
@@ -118,9 +141,20 @@ export class STLParser {
       const vertHolder = new VertexHolder();
       for (var v = 3; v < 12; v += 3) {
         var vert = new Vertex(dv.getFloat32(v * 4, le), dv.getFloat32((v + 1) * 4, le), dv.getFloat32((v + 2) * 4, le));
-        vertHolder["vert" + v / 3] = vert;
+        // vertHolder["vert" + v / 3] = vert;
+        const vIndex = v / 3;
+        switch( vIndex ) {
+          case 1: vertHolder.vert1 = vert; break;
+          case 2: vertHolder.vert2 = vert; break;
+          case 3: vertHolder.vert3 = vert; break;
+          default: console.warn("[STLParser] Warning, binary vertex component index unexpeced.", vIndex);
+        }
+      }
+      if( vertHolder.vert1 && vertHolder.vert2 && vertHolder.vert3 ) {
+        this.handleFacet(vertHolder.vert1, vertHolder.vert2, vertHolder.vert3, normal);
+      } else {
+        console.warn("[STLParser] Warning, cannot add binary vertex to mesh. vertex not fully defined.");
       }
-      this.handleFacet(vertHolder.vert1, vertHolder.vert2, vertHolder.vert3, normal);
     }
   }