plotboilerplate 1.12.10 → 1.16.0

package/src/ts/utils/io/FileDrop.ts

@@ -0,0 +1,178 @@
+/**
+ * A basic IO handler for file drop (Drag-and-drop).
+ *
+ * Example use:
+ * ```javascript
+ *  var body = document.getElememtByTagName("body")[0];
+ *  var fileDrop = new FileDrop(body);
+ *    fileDrop.onFileJSONDropped(function (jsonObject) {
+ *    console.log("jsonObject", jsonObject);
+ *  });
+ * ```
+ *
+ * @author   Ikaros Kappler
+ * @date     2021-10-13
+ * @modified 2022-01-31 (ported from the ngdg project, then generalized)
+ * @version  2.0.0
+ */
+
+type IDroppedCallbackJSON = (jsonData: object) => void;
+type IDroppedCallbackText = (textData: string) => void;
+type IDroppedCallbackBinary = (binaryData: Blob, file: File) => void;
+
+export class FileDrop {
+  /**
+   * The 'dropzone' element.
+   * @private
+   * @memberof FileDrop
+   * @member {HTMLElement}
+   */
+  private element: HTMLElement;
+
+  /**
+   * The JSON file drop callback.
+   * @private
+   * @memberof FileDrop
+   * @member {HTMLElement}
+   */
+  private fileDroppedCallbackJSON: IDroppedCallbackJSON | null;
+
+  /**
+   * The text file drop callback.
+   * @private
+   * @memberof FileDrop
+   * @member {HTMLElement}
+   */
+  private fileDroppedCallbackText: IDroppedCallbackText | null;
+
+  /**
+   * The binary file drop callback.
+   * @private
+   * @memberof FileDrop
+   * @member {HTMLElement}
+   */
+  private fileDroppedCallbackBinary: IDroppedCallbackBinary | null;
+
+  /**
+   *
+   * @param {HTMLElement} element - The element you wish to operate as the drop zone (like <body/>).
+   */
+  constructor(element: HTMLElement) {
+    this.element = element;
+
+    // Init the drop listeners
+    element.addEventListener("drop", this.handleDropEvent.bind(this));
+    element.addEventListener("dragover", this.handleDragOverEvent.bind(this));
+    element.addEventListener("dragleave", this.handleDragLeaveEvent.bind(this));
+  }
+
+  /**
+   * Install the JSON (MIME type json*) file drop callback. Note than only one callback can be installed
+   * in this implementation. Calling this method multiple times will overwrite previously
+   * installed listeners.
+   *
+   * The callback will receive the dropped file content as an object (parsed JSON).
+   *
+   * @param {(data:object)=>void} callback
+   */
+  onFileJSONDropped(callback: IDroppedCallbackJSON) {
+    this.fileDroppedCallbackJSON = callback;
+  }
+
+  /**
+   * Install the text file (MIME type text/plain) drop callback. Note than only one callback can be installed
+   * in this implementation. Calling this method multiple times will overwrite previously
+   * installed listeners.
+   *
+   * The callback will receive the dropped file content as a string.
+   *
+   * @param {(data:object)=>void} callback
+   */
+  onFileTextDropped(callback: IDroppedCallbackText) {
+    this.fileDroppedCallbackText = callback;
+  }
+
+  /**
+   * Internally handle a drop event.
+   *
+   * @param {DragEvent} event
+   * @returns {void}
+   */
+  private handleDropEvent = (event: DragEvent) => {
+    event.preventDefault();
+    event.stopPropagation();
+    this.element.style.opacity = "1.0";
+
+    if (!event.dataTransfer.files || event.dataTransfer.files.length === 0) {
+      // No files were dropped
+      return;
+    }
+    if (event.dataTransfer.files.length > 1) {
+      // Multiple file drop is not nupported
+      return;
+    }
+    if (!this.fileDroppedCallbackJSON) {
+      // No handling callback defined.
+      return;
+    }
+    if (event.dataTransfer.files[0]) {
+      const file: File = event.dataTransfer.files[0];
+      // console.log("file", file);
+      if (file.type.match(/json.*/) && this.fileDroppedCallbackJSON) {
+        var reader = new FileReader();
+        reader.onload = (readEvent: ProgressEvent<FileReader>) => {
+          // Finished reading file data.
+          const jsonObject: object = JSON.parse(readEvent.target.result as string);
+          // TODO: what happens on fail?
+          this.fileDroppedCallbackJSON(jsonObject);
+        };
+        reader.readAsText(file); // start reading the file data.
+      } else if (file.type.match(/text\/plain.*/) && this.fileDroppedCallbackText) {
+        var reader = new FileReader();
+        reader.onload = (readEvent: ProgressEvent<FileReader>) => {
+          // Finished reading file data.
+          this.fileDroppedCallbackText(readEvent.target.result as string);
+        };
+        reader.readAsText(file); // start reading the file data.
+      } else if (this.fileDroppedCallbackBinary) {
+        var reader = new FileReader();
+        reader.onload = (readEvent: ProgressEvent<FileReader>) => {
+          // Finished reading file data.
+          this.fileDroppedCallbackBinary(new Blob([readEvent.target.result]), file);
+        };
+        reader.readAsBinaryString(file); // start reading the file data.
+      }
+    }
+  };
+
+  /**
+   * Toggles the drop sensitive element's opacity to 0.5.
+   *
+   * @param {DragEvent} event - The event.
+   */
+  private handleDragOverEvent = (event: DragEvent) => {
+    event.preventDefault();
+    event.stopPropagation();
+    this.element.style.opacity = "0.5";
+  };
+
+  /**
+   * Restored the drop sensitive element's opacity back to 1.0.
+   *
+   * @param {DragEvent} event - The event.
+   */
+  private handleDragLeaveEvent = (event: DragEvent) => {
+    event.preventDefault();
+    event.stopPropagation();
+    this.element.style.opacity = "1.0";
+  };
+
+  /**
+   * Removes all listeners (drop, dragover and dragleave).
+   */
+  destroy() {
+    this.element.removeEventListener("drop", this.handleDropEvent);
+    this.element.removeEventListener("dragover", this.handleDragOverEvent);
+    this.element.removeEventListener("dragleave", this.handleDragLeaveEvent);
+  }
+}

package/dist/plotboilerplate.browser.min.js.LICENSE.txt

@@ -1,8 +0,0 @@
-/**
- * index.es6 v0.1.17
- * super tiny size multi-touch gestures library for the web. Cloned from alloyfinger
- *
- * @author dntzhang
- * @license MIT
- * @preserve
- */

package/src/ts/utils/algorithms/clearPolygonDuplicateVertices.ts~

@@ -1,5 +0,0 @@
-/**
- *
- */
-
-const polygonClearDuplicateVertices

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

@@ -1,45 +0,0 @@
-/**
- * @requires Line
- * @requires Vertex
- *
- * @author Ikaros Kappler
- * @date   2020-12-04
- */
-
-
-/**
- * Collect all self-intersection points of the given polygon.
- *
- * @name findPolygonSelfIntersections
- * @param {Array<Vertex>} polygon
- * @return Array<Vertex>
- */
-var findPolygonSelfIntersections = function( polygon ) {
-    var pointList = [];
-    var lineA = new Line( new Vertex(), new Vertex() );
-    var lineB = new Line( new Vertex(), new Vertex() );
-    for( var a = 0; a < polygon.vertices.length; a++ ) {
-	lineA.a.set( polygon.getVertexAt(a) );
-	lineA.b.set( polygon.getVertexAt(a+1) );
-	for( var b = 0; b < polygon.vertices.length; b++ ) {
-	    // Same edge or neighbour edges intersect by definition.
-	    // Skip them.
-	    if( a == b || a+1 == b || a == b+1
-		|| (a==0&&b+1==polygon.vertices.length) || (b==0&&a+1==polygon.vertices.length) )
-		continue;
-	    lineB.a.set( polygon.getVertexAt(b) );
-	    lineB.b.set( polygon.getVertexAt(b+1) );
-
-	    // Commpute the intersection point of the (infinite) lines.
-	    // The point is undefined if and only if both line are parallel (co-linear).
-	    const intersectionPoint = 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 );
-	    }
-	}	
-    }
-    return pointList;
-};

package/src/ts/utils/algorithms/sh-tmp.ts~

@@ -1,59 +0,0 @@
-
-interface XYCoords  {
-    x : number;
-    y : number;
-}
-
-const inside = ( cp1 : XYCoords, cp2 : XYCoords, p : XYCoords) : boolean => {
-    return (cp2.x-cp1.x)*(p.y-cp1.y) > (cp2.y-cp1.y)*(p.x-cp1.x);
-};
-
-const intersection = ( cp1 : XYCoords ,cp2 : XYCoords ,s : XYCoords, e : XYCoords ) : XYCoords => {
-    const dc = {
-	x:  cp1.x - cp2.x,
-	y : cp1.y - cp2.y
-	 },
-    dp = { x: s.x - e.x,
-	   y : s.y - e.y
-	 },
-    n1 = cp1.x * cp2.y - cp1.y * cp2.x,
-    n2 = s.x * e.y - s.y * e.x, 
-    n3 = 1.0 / (dc.x * dp.y - dc.y * dp.x);
-    return { x : (n1*dp.x - n2*dc.x) * n3,
-	     y : (n1*dp.y - n2*dc.y) * n3
-	   };
-};
-
-export const sutherlandHodgman = ( subjectPolygon : Array<XYCoords>,
-				   clipPolygon : Array<XYCoords> ) : Array<XYCoords> => {
-    
-    let cp1 : XYCoords = clipPolygon[clipPolygon.length-1];
-    let cp2 : XYCoords;
-    let s : XYCoords;
-    let e : XYCoords;
-    
-    let outputList : Array<XYCoords> = subjectPolygon;
-    
-    for( var j in clipPolygon ) {
-        cp2 = clipPolygon[j];
-        var inputList = outputList;
-        outputList = [];
-        s = inputList[inputList.length - 1]; // last on the input list
-        for (var i in inputList) {
-	    e = inputList[i];
-	    if (inside(cp1,cp2,e)) {
-                if (!inside(cp1,cp2,s)) {
-		    outputList.push(intersection(cp1,cp2,s,e));
-                }
-                outputList.push(e);
-	    }
-	    else if (inside(cp1,cp2,s)) {
-                outputList.push(intersection(cp1,cp2,s,e));
-	    }
-	    s = e;
-        }
-        cp1 = cp2;
-    }
-    return outputList
-}
-

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

@@ -1,113 +0,0 @@
-/**
- * This function cuts a given self-intersecting polygon into non-self-intersecting 
- * sub polygons.
- *
- * The algorithm only works for non-self-overlapping polygons.
- * Please note that the union set of the sub polygons themselves will _not_ be disjunct if
- * the input polyon overlaps with itself!
- *
- *
- * @requires Line
- * @requires Vertex
- * @requires greinerHormann
- * 
- * @date 2020-12-04
- */
-
-(function(_context) {
-
-    /**
-     * @param {Array<Vertex>} vertices
-     * @param {number=10} maxDepth
-     */  
-    var splitToNonIntersectingPolygons = function( vertices, maxDepth ) {
-	if( typeof maxDepth === "undefined" )
-	    maxDepth = 10;
-	return _splitToNonIntersectingPolygons( vertices, maxDepth );
-    };
-
-    
-    var _splitToNonIntersectingPolygons = function( vertices, maxDepth ) {
-
-	if( maxDepth <= 0 ) {
-	    console.log('aborting at max depth');
-	    return [ vertices ];
-	}
-
-	if( vertices.length <= 3 ) {
-	    // No intersections possible
-	    return [ vertices ];
-	}
-
-	// var pointList = [];
-	var n = vertices.length;
-	var lineA = new Line( new Vertex(), new Vertex() );
-	var lineB = 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 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 = lineA.intersection(lineB);
-		// console.log( 'intersectionPoint', intersectionPoint );
-		if( intersectionPoint && lineA.hasPoint(intersectionPoint) && lineB.hasPoint(intersectionPoint) ) {
-		    // console.log( 'intersection found' );
-		    // pointList.push( intersectionPoint );
-		    // Cut polygon into two here
-		    var split = splitPolygonAt( vertices, a, b, intersectionPoint );
-		    
-		    // Split has 2 elements.
-		    var leftCleaned = _splitToNonIntersectingPolygons( split[0], maxDepth-1 );
-		    var rightCleaned =  _splitToNonIntersectingPolygons( split[1], maxDepth-1 );
-
-		    return leftCleaned.concat( rightCleaned );
-		}
-	    }	
-	}
-	// console.log( 'intersectionPoints', pointList );
-
-	// No intersection found:
-	//    just return a list with the original
-	//    polygon as its only element.
-	return [ vertices ];
-    };
-
-
-    // Pre: edgeIndexA < edgeIndexB && vertices.length >= 4
-    var splitPolygonAt = function( vertices, edgeIndexA, edgeIndexB, intersectionPoint ) {
-
-	// console.log( 'split', edgeIndexA, edgeIndexB );
-	
-	var first = [];
-	var second = [];
-	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] );
-	    
-	}
-
-	// console.log( 'split', first, second );
-
-	return [ first, second ];
-    };
-
-    _context.splitToNonIntersectingPolygons = splitToNonIntersectingPolygons;
-
-})(globalThis || window);

package/src/ts/utils/algorithms/sutherlandHodgman.ts~

@@ -1,88 +0,0 @@
-"use strict";
-
-/**
- * The Sutherland-Hodgman convex polygon clipping algorithm.
- *
- * Converted to Vertex variant {x:number,y:number} by Ikaros Kappler.
- *
- * @date    2021-01-29
- * @version 1.0.0
- *
- * Original version:
- *    https://rosettacode.org/wiki/Sutherland-Hodgman_polygon_clipping#JavaScript
- */
-
-
-
-(function() {
-
-
-    /**
-     * @param {Vertex}
-     * @param {Vertex}
-     **/
-    var inside = function (_cp1,_cp2,p) {
-	// console.log('x', _cp1);
-        return (_cp2.x-_cp1.x)*(p.y-_cp1.y) > (_cp2.y-_cp1.y)*(p.x-_cp1.x);
-    };
-
-    /**
-     * @param {Vertex}
-     * @param {Vertex}
-     * @param {Vertex}
-     * @param {Vertex}
-     */
-    var intersection = function (_cp1,_cp2,_s,_e) {
-        var
-	dc = { x:  _cp1.x - _cp2.x,
-	       y : _cp1.y - _cp2.y
-	     },
-	dp = { x: _s.x - _e.x,
-	       y : _s.y - _e.y
-	     },
-        n1 = _cp1.x * _cp2.y - _cp1.y * _cp2.x,
-        n2 = _s.x * _e.y - _s.y * _e.x, 
-        n3 = 1.0 / (dc.x * dp.y - dc.y * dp.x);
-        return { x : (n1*dp.x - n2*dc.x) * n3,
-		 y : (n1*dp.y - n2*dc.y) * n3
-	       };
-    };
-    
-
-    /**
-     * @param {Array<Vertex>} subjectPolygon
-     * @param {Array<Vertex>} clipPolygon - Must be convex.
-     */
-    var sutherlandHodgman = function(subjectPolygon, clipPolygon) {
-	
-	var cp1, cp2, s, e;
-	
-	var outputList = subjectPolygon;
-	cp1 = clipPolygon[clipPolygon.length-1];
-	
-	for (var j in clipPolygon) {
-            var cp2 = clipPolygon[j];
-            var inputList = outputList;
-            outputList = [];
-            s = inputList[inputList.length - 1]; // last on the input list
-            for (var i in inputList) {
-		var e = inputList[i];
-		if (inside(cp1,cp2,e)) {
-                    if (!inside(cp1,cp2,s)) {
-			outputList.push(intersection(cp1,cp2,s,e));
-                    }
-                    outputList.push(e);
-		}
-		else if (inside(cp1,cp2,s)) {
-                    outputList.push(intersection(cp1,cp2,s,e));
-		}
-		s = e;
-            }
-            cp1 = cp2;
-	}
-	return outputList
-    }
-
-    globalThis.sutherlandHodgman = sutherlandHodgman;
-
-})();