plotboilerplate 1.23.3 → 1.25.0

package/src/ts/BezierPath.ts

@@ -25,7 +25,10 @@
  * @modified 2022-02-02 Cleared the `toSVGString` function (deprecated). Use `drawutilssvg` instead.
  * @modified 2023-10-06 Adding the `BezierPath.toPathPoints()` method.
  * @modified 2023-10-07 Adding the `BezierPath.fromCurve(CubicBezierCurve)` static function.
- * @version 2.6.0
+ * @modified 2025-04-09 Added the `BezierPath.move` method to match the convention – which just calls `translate`.
+ * @modified 2025-04-09 Modified the `BezierPath.translate` method: chaning parameter `Vertex` to more generalized `XYCoords`.
+ * @modified 2025-04-14 Class `BezierPath` is now implementing interface `Intersectable`.
+ * @version 2.7.0
  *
  * @file BezierPath
  * @public
@@ -34,8 +37,10 @@
 import { Bounds } from "./Bounds";
 import { CubicBezierCurve } from "./CubicBezierCurve";
 import { UIDGenerator } from "./UIDGenerator";
+import { Vector } from "./Vector";
+import { VertTuple } from "./VertTuple";
 import { Vertex } from "./Vertex";
-import { XYCoords, SVGSerializable, UID } from "./interfaces";
+import { XYCoords, SVGSerializable, UID, Intersectable, IBounded } from "./interfaces";
 
 /**
  * @classdesc A BezierPath class.
@@ -50,7 +55,7 @@ import { XYCoords, SVGSerializable, UID } from "./interfaces";
  * @requires UID
  * @requires UIDGenerator
  **/
-export class BezierPath implements SVGSerializable {
+export class BezierPath implements IBounded, Intersectable, SVGSerializable {
   /**
    * Required to generate proper CSS classes and other class related IDs.
    **/
@@ -309,13 +314,13 @@ export class BezierPath implements SVGSerializable {
    * Move the whole bezier path by the given (x,y)-amount.
    *
    * @method translate
-   * @param {Vertex} amount - The amount to be added (amount.x and amount.y)
+   * @param {XYCoords} amount - The amount to be added (amount.x and amount.y)
    *                          to each vertex of the curve.
    * @instance
    * @memberof BezierPath
    * @return {BezierPath} this for chaining
    **/
-  translate(amount: Vertex): BezierPath {
+  translate(amount: XYCoords): BezierPath {
     for (var i = 0; i < this.bezierCurves.length; i++) {
       var curve = this.bezierCurves[i];
       curve.getStartPoint().add(amount);
@@ -331,6 +336,20 @@ export class BezierPath implements SVGSerializable {
     return this;
   }
 
+  /**
+   * Move the whole bezier path by the given (x,y)-amount.
+   *
+   * @method move
+   * @param {XYCoords} amount - The amount to be added (amount.x and amount.y)
+   *                          to each vertex of the curve.
+   * @instance
+   * @memberof BezierPath
+   * @return {BezierPath} this for chaining
+   **/
+  move(amount: XYCoords): BezierPath {
+    return this.translate(amount);
+  }
+
   /**
    * Scale the whole bezier path by the given uniform factor.
    *
@@ -559,6 +578,38 @@ export class BezierPath implements SVGSerializable {
     return bCurve.getPerpendicular(relativeU);
   }
 
+  //--- BEGIN --- Implement interface `Intersectable`
+  /**
+   * Get all line intersections with this shape.
+   *
+   * This method returns all intersections (as vertices) with this shape. The returned array of vertices is in no specific order.
+   *
+   * @param {VertTuple} line - The line to find intersections with.
+   * @param {boolean} inVectorBoundsOnly - If set to true only intersecion points on the passed vector are returned (located strictly between start and end vertex).
+   * @returns {Array<Vertex>} - An array of all intersections with the shape's outline.
+   */
+  lineIntersections(line: VertTuple<any>, inVectorBoundsOnly: boolean = false): Array<Vertex> {
+    return this.bezierCurves.reduce((accu: Array<Vertex>, curCurve: CubicBezierCurve) => {
+      return accu.concat(curCurve.lineIntersections(line, inVectorBoundsOnly));
+    }, []);
+  }
+
+  /**
+   * Get all line intersections of this polygon and their tangents along the shape.
+   *
+   * This method returns all intersection tangents (as vectors) with this shape. The returned array of vectors is in no specific order.
+   *
+   * @param line
+   * @param lineIntersectionTangents
+   * @returns
+   */
+  lineIntersectionTangents(line: VertTuple<any>, inVectorBoundsOnly: boolean = false): Array<Vector> {
+    return this.bezierCurves.reduce((accu: Array<Vector>, curCurve: CubicBezierCurve) => {
+      return accu.concat(curCurve.lineIntersectionTangents(line, inVectorBoundsOnly));
+    }, []);
+  }
+  //--- END --- Implement interface `Intersectable`
+
   /**
    * This is a helper function to locate the curve index for a given
    * absolute path position u.
@@ -816,6 +867,7 @@ export class BezierPath implements SVGSerializable {
     neighbourCurve.updateArcLengths();
   }
 
+  //--- BEGIN --- Implement interface `IBounded`
   /**
    * Get the bounds of this Bézier path.
    *
@@ -837,6 +889,7 @@ export class BezierPath implements SVGSerializable {
     }
     return new Bounds(min, max);
   }
+  //--- END --- Implement interface `IBounded`
 
   /**
    * Get n 'equally' distributed vertices along this Bézier path.

package/src/ts/Bounds.ts

@@ -9,13 +9,16 @@
  * @modified 2022-10-09 Added the `fromDimension` function.
  * @modified 2022-11-28 Added the `clone` method.
  * @modified 2023-09-29 Added the `randomPoint` method.
- * @version  1.7.0
+ * @modified 2025-03-23 Added the `getMinDimension` and `getMaxDimension` methods.
+ * @modified 2025-04-18 Change parameter type in `Bounds.computeFromVertices` from `Vertex` to more general `XYCoords`.
+ * @modified 2025-04-19 Added methods to `Bounds` class: `getNorthPoint`, `getSouthPoint`, `getEastPoint` and `getWestPoint`.
+ * @modified 2025-04-26 Added static method `Bounds.computeFromBoundsSet` to calculate containing bounds for a set of bounding boxes.
+ * @version  1.8.0
  **/
 
 import { Polygon } from "./Polygon";
 import { XYCoords, IBounds, XYDimension } from "./interfaces";
 import { Vertex } from "./Vertex";
-import { VertTuple } from "./VertTuple";
 
 /**
  * @classdesc A bounds class with min and max values. Implementing IBounds.
@@ -72,6 +75,55 @@ export class Bounds implements IBounds, XYDimension {
     this.height = max.y - min.y;
   }
 
+  /**
+   * Get the center point of the north bound.
+   * 
+   * @method getNorthPoint
+   * @instance
+   * @memberof Bounds
+   * @return {Vertex} The "northmost" centered point of this bounding box.
+   */
+  getNorthPoint() : Vertex {
+    return new Vertex(this.min.x + this.width/2.0,  this.min.y );
+  };
+
+  /**
+   * Get the center point of the south bound.
+   * 
+   * @method getNorthPoint
+   * @instance
+   * @memberof Bounds
+   * @return {Vertex} The "southhmost" centered point of this bounding box.
+   */
+  getSouthPoint() : Vertex {
+    return new Vertex( this.min.x + this.width/2.0, this.max.y );
+  };
+
+   /**
+   * Get the center point of the west bound.
+   * 
+   * @method getWestPoint
+   * @instance
+   * @memberof Bounds
+   * @return {Vertex} The "westhmost" centered point of this bounding box.
+   */
+   getWestPoint() : Vertex {
+    return new Vertex( this.min.x, this.min.y + this.height/2.0 );
+  };
+
+   /**
+   * Get the center point of the east bound.
+   * 
+   * @method getEastPoint
+   * @instance
+   * @memberof Bounds
+   * @return {Vertex} The "easthmost" centered point of this bounding box.
+   */
+   getEastPoint() : Vertex {
+    return new Vertex( this.max.x, this.min.y + this.height/2.0 );
+  };
+
+
   /**
    * Convert this rectangular bounding box to a polygon with four vertices.
    *
@@ -99,6 +151,24 @@ export class Bounds implements IBounds, XYDimension {
     return new Vertex(this.min.x + (this.max.x - this.min.x) / 2.0, this.min.y + (this.max.y - this.min.y) / 2);
   }
 
+  /**
+   * Get the minimum of `width` and `height`.
+   *
+   * @returns {number} The value of Math.min( this.width, this.height )
+   */
+  getMinDimension(): number {
+    return Math.min(this.width, this.height);
+  }
+
+  /**
+   * Get the minimum of `width` and `height`.
+   *
+   * @returns {number} The value of Math.min( this.width, this.height )
+   */
+  getMaxDimension(): number {
+    return Math.max(this.width, this.height);
+  }
+
   /**
    * Generate a random point inside this bounds object. Safe areas at the border to avoid
    * included.
@@ -156,18 +226,20 @@ export class Bounds implements IBounds, XYDimension {
    * @static
    * @method computeFromVertices
    * @memberof Bounds
-   * @param {Array<Vertex>} vertices - The set of vertices you want to get the bounding box for.
+   * @param {Array<XYCoords>} vertices - The set of vertices you want to get the bounding box for.
    * @return The minimal Bounds for the given vertices.
    **/
-  static computeFromVertices(vertices: Array<Vertex>): Bounds {
-    if (vertices.length == 0) return new Bounds(new Vertex(0, 0), new Vertex(0, 0));
+  static computeFromVertices(vertices: Array<XYCoords>): Bounds {
+    if (vertices.length == 0) { 
+      return new Bounds(new Vertex(0, 0), new Vertex(0, 0));
+    }
 
     let xMin = vertices[0].x;
     let xMax = vertices[0].x;
     let yMin = vertices[0].y;
     let yMax = vertices[0].y;
 
-    let vert: Vertex;
+    let vert: XYCoords;
     for (var i in vertices) {
       vert = vertices[i];
       xMin = Math.min(xMin, vert.x);
@@ -178,6 +250,38 @@ export class Bounds implements IBounds, XYDimension {
     return new Bounds(new Vertex(xMin, yMin), new Vertex(xMax, yMax));
   }
 
+   /**
+   * Compute the minimal bounding box for a given set of existing bounding boxes.
+   *
+   * An empty vertex array will return an empty bounding box located at (0,0).
+   *
+   * @static
+   * @method computeFromBoundsSet
+   * @memberof Bounds
+   * @param {Array<IBounds>} boundingBoxes - The set of existing bounding boxes to get the containing bounding box for.
+   * @return The minimal Bounds for the given bounds instances.
+   **/
+  static computeFromBoundsSet(boundingBoxes:Array<IBounds>) : Bounds {
+    if (boundingBoxes.length == 0) {
+      return new Bounds(new Vertex(0, 0), new Vertex(0, 0));
+    }
+
+    let xMin = boundingBoxes[0].min.x;
+    let xMax = boundingBoxes[0].max.x;
+    let yMin = boundingBoxes[0].min.y;
+    let yMax = boundingBoxes[0].min.y;
+
+    let bounds: IBounds;
+    for (var i in boundingBoxes) {
+      bounds = boundingBoxes[i];
+      xMin = Math.min(xMin, bounds.min.x);
+      xMax = Math.max(xMax, bounds.max.x);
+      yMin = Math.min(yMin, bounds.min.y);
+      yMax = Math.max(yMax, bounds.min.y);
+    }
+    return new Bounds(new Vertex(xMin, yMin), new Vertex(xMax, yMax));
+  }
+
   /**
    * Create a new `Bounds` instance just from `width` and `height`, located at (0,0) or the optionally given origin.
    *

package/src/ts/Circle.ts

@@ -12,15 +12,18 @@
  * @modified 2022-08-15 Added the `containsPoint` function.
  * @modified 2022-08-23 Added the `lineIntersection` function.
  * @modified 2022-08-23 Added the `closestPoint` function.
- * @version  1.4.0
+ * @modified 2025-04-09 Added the `Circle.move(amount: XYCoords)` method.
+ * @modified 2025-04-16 Class `Circle` now implements interface `Intersectable`.
+ * @version  1.5.0
  **/
 
+import { Bounds } from "./Bounds";
 import { Line } from "./Line";
 import { UIDGenerator } from "./UIDGenerator";
 import { Vector } from "./Vector";
 import { VertTuple } from "./VertTuple";
 import { Vertex } from "./Vertex";
-import { SVGSerializable, UID, XYCoords } from "./interfaces";
+import { IBounded, Intersectable, SVGSerializable, UID, XYCoords } from "./interfaces";
 
 /**
  * @classdesc A simple circle: center point and radius.
@@ -33,7 +36,7 @@ import { SVGSerializable, UID, XYCoords } from "./interfaces";
  * @requires UID
  * @requires UIDGenerator
  **/
-export class Circle implements SVGSerializable {
+export class Circle implements IBounded, Intersectable, SVGSerializable {
   /**
    * Required to generate proper CSS classes and other class related IDs.
    **/
@@ -85,6 +88,20 @@ export class Circle implements SVGSerializable {
     this.radius = radius;
   }
 
+  /**
+   * Move the circle by the given amount.
+   *
+   * @method move
+   * @param {XYCoords} amount - The amount to move.
+   * @instance
+   * @memberof Circle
+   * @return {Circle} this for chaining
+   **/
+  move(amount: XYCoords): Circle {
+    this.center.add(amount);
+    return this;
+  }
+
   /**
    * Check if the given circle is fully contained inside this circle.
    *
@@ -159,8 +176,26 @@ export class Circle implements SVGSerializable {
     const pointA: Vertex = Circle.circleUtils.vertAt(angle, this.radius);
     // Construct the perpendicular of the line in point a. Then move relative to center.
     return (new Vector(pointA, new Vertex(0, 0)).add(this.center) as Vector).perp() as Vector;
+    // return (new Vector(this.center.clone(), pointA).add(pointA) as Vector).perp() as Vector;
   }
 
+  //--- BEGIN --- Implement interface `Intersectable`
+  /**
+   * Get the bounding box (bounds) of this Circle.
+   *
+   * @method getBounds
+   * @instance
+   * @memberof Circle
+   * @return {Bounds} The rectangular bounds of this Circle.
+   **/
+  getBounds(): Bounds {
+    return new Bounds(
+      this.center.clone().subXY(Math.abs(this.radius), Math.abs(this.radius)),
+      this.center.clone().addXY(Math.abs(this.radius), Math.abs(this.radius))
+    );
+  }
+  //--- END --- Implement interface `Intersectable`
+
   /**
    * Calculate the intersection points (if exists) with the given circle.
    *
@@ -221,7 +256,7 @@ export class Circle implements SVGSerializable {
    * @instance
    * @memberof Circle
    * @param {Vertex} a- The first of the two points defining the line.
-   * @param {Vertex} b - The second of the two points defining the line.
+   * @param {XYCoords} b - The second of the two points defining the line.
    * @return {Line|null} The intersection points (as a line) or null if this circle does not intersect the line given.
    **/
   lineIntersection(a: Vertex, b: XYCoords): Line | null {
@@ -262,9 +297,56 @@ export class Circle implements SVGSerializable {
     interB.y = (-det * diff.x - Math.abs(diff.y) * sqrt) / distSquared;
 
     return new Line(interA.add(this.center), interB.add(this.center));
-    // return new Line(interA, interB);
   }
 
+  //--- BEGIN --- Implement interface `Intersectable`
+  /**
+   * Get all line intersections with this circle.
+   *
+   * This method returns all intersections (as vertices) with this shape. The returned array of vertices is in no specific order.
+   *
+   * @param {VertTuple} line - The line to find intersections with.
+   * @param {boolean} inVectorBoundsOnly - If set to true only intersecion points on the passed vector are returned (located strictly between start and end vertex).
+   * @returns {Array<Vertex>} - An array of all intersections with the circle outline.
+   */
+  lineIntersections(line: VertTuple<any>, inVectorBoundsOnly: boolean = false): Array<Vertex> {
+    // Find the intersections of all lines inside the edge bounds
+    const intersectioLine: Line | null = this.lineIntersection(line.a, line.b);
+    if (!intersectioLine) {
+      return [];
+    }
+    if (inVectorBoundsOnly) {
+      // const maxDist = line.length();
+      return [intersectioLine.a, intersectioLine.b].filter((vert: Vertex) => line.hasPoint(vert, true));
+    } else {
+      return [intersectioLine.a, intersectioLine.b];
+    }
+  }
+
+  /**
+   * Get all line intersections of this polygon and their tangents along the shape.
+   *
+   * This method returns all intersection tangents (as vectors) with this shape. The returned array of vectors is in no specific order.
+   *
+   * @param line
+   * @param lineIntersectionTangents
+   * @returns
+   */
+  lineIntersectionTangents(line: VertTuple<any>, inVectorBoundsOnly: boolean = false): Array<Vector> {
+    // Find the intersections of all lines plus their tangents inside the circle bounds
+    const interSectionPoints: Array<Vertex> = this.lineIntersections(line, inVectorBoundsOnly);
+    return interSectionPoints.map((vert: Vertex) => {
+      // Calculate angle
+      const lineFromCenter = new Line(this.center, vert);
+      const angle: number = lineFromCenter.angle();
+      // console.log("angle", (angle / Math.PI) * 180.0);
+      // const angle = Math.random() * Math.PI * 2; // TODO
+      // Calculate tangent at angle
+      return this.tangentAt(angle);
+    });
+  }
+  //--- END --- Implement interface `Intersectable`
+
   /**
    * Calculate the closest point on the outline of this circle to the given point.
    *

package/src/ts/CircleSector.ts

@@ -8,14 +8,22 @@
  * @modified 2024-03-08 Added the `containsAngle` method.
  * @modified 2024-03-09 Added the `circleSectorIntersection` method to find coherent sector intersections..
  * @modified 2024-03-09 Added the `angleAt` method to determine any angle at some ratio.
+ * @modified 2025-04-02 Adding the `CircleSector.lineIntersections` and `CircleSector.lineIntersectionTangents` and implementing `Intersectable`.
+ * @modified 2025-04-09 Adding the `CircleSector.move()` method.
+ * @modified 2025-04-19 Tweaking the `CircleSector.containsAngle` method: all values (input angle, start- and end- angle) are wrapped into [0,2*PI) now.
+ * @modified 2025-04-19 Class `CircleSector` implements interface `Bounded` now (method `getBounds` added).
  * @version  1.2.0
  **/
 
+import { Bounds } from "./Bounds";
 import { Circle } from "./Circle";
 import { Line } from "./Line";
 import { UIDGenerator } from "./UIDGenerator";
+import { Vector } from "./Vector";
+import { VertTuple } from "./VertTuple";
 import { Vertex } from "./Vertex";
-import { PathSegment, SVGPathParams, SVGSerializable, UID, XYCoords } from "./interfaces";
+import { geomutils } from "./geomutils";
+import { IBounded, Intersectable, SVGPathParams, SVGSerializable, UID, XYCoords } from "./interfaces";
 
 /**
  * @classdesc A simple circle sector: circle, start- and end-angle.
@@ -26,7 +34,7 @@ import { PathSegment, SVGPathParams, SVGSerializable, UID, XYCoords } from "./in
  * @requires UIDGenerator
  * @requires XYCoords
  **/
-export class CircleSector implements SVGSerializable {
+export class CircleSector implements IBounded, Intersectable, SVGSerializable {
   /**
    * Required to generate proper CSS classes and other class related IDs.
    **/
@@ -87,6 +95,52 @@ export class CircleSector implements SVGSerializable {
     this.endAngle = endAngle;
   }
 
+  //--- BEGIN --- Implement interface `IBounded`
+  /**
+   * Get the bounds of this ellipse.
+   *
+   * The bounds are approximated by the underlying segment buffer; the more segment there are,
+   * the more accurate will be the returned bounds.
+   *
+   * @method getBounds
+   * @instance
+   * @memberof VEllipse
+   * @return {Bounds} The bounds of this curve.
+   **/
+  getBounds(): Bounds {
+    const _self = this;
+    const circleBounds : Bounds = this.circle.getBounds();
+    // Calculage angles from east, west, north and south box points and check if they are inside
+    const candidates : Array<Vertex> = [
+      circleBounds.getNorthPoint(),
+      circleBounds.getSouthPoint(),
+      circleBounds.getWestPoint(),
+      circleBounds.getEastPoint()
+    ].filter( (point : Vertex) => {
+      // Check for each candidate points if they are contained in this sector. Drop if not.
+      const angle : number = new Line(_self.circle.center, point).angle();
+      return _self.containsAngle(angle);
+    });
+    // Compute bounds and inlcude start end end point (they are definitely part of the bounds)
+    return Bounds.computeFromVertices(candidates.concat([this.getStartPoint(), this.getEndPoint()]));
+  }
+  //--- BEGIN --- Implement interface `IBounded`
+
+
+  /**
+   * Move the circle sector by the given amount.
+   *
+   * @method move
+   * @param {XYCoords} amount - The amount to move.
+   * @instance
+   * @memberof CircleSector
+   * @return {CircleSector} this for chaining
+   **/
+  move(amount: XYCoords): CircleSector {
+    this.circle.move(amount);
+    return this;
+  }
+
   /**
    * Checks wether the given angle (must be inside 0 and PI*2) is contained inside this sector.
    *
@@ -97,11 +151,21 @@ export class CircleSector implements SVGSerializable {
    * @return {boolean} True if (and only if) this sector contains the given angle.
    */
   containsAngle(angle: number) {
-    if (this.startAngle <= this.endAngle) {
-      return angle >= this.startAngle && angle < this.endAngle;
+    var wrappedAngle = geomutils.mapAngleTo2PI(angle);
+    var wrappedStart = geomutils.mapAngleTo2PI(this.startAngle);
+    var wrappedEnd = geomutils.mapAngleTo2PI(this.endAngle);
+    // TODO: cleanup
+    // if (this.startAngle <= this.endAngle) {
+    //   return angle >= this.startAngle && angle < this.endAngle;
+    // } else {
+    //   // startAngle > endAngle
+    //   return angle >= this.startAngle || angle < this.endAngle;
+    // }
+    if (wrappedStart <= wrappedEnd) {
+      return wrappedAngle >= wrappedStart && wrappedAngle < wrappedEnd;
     } else {
       // startAngle > endAngle
-      return angle >= this.startAngle || angle < this.endAngle;
+      return wrappedAngle >= wrappedStart || wrappedAngle < wrappedEnd;
     }
   }
 
@@ -206,6 +270,52 @@ export class CircleSector implements SVGSerializable {
     return resultSector;
   }
 
+  //--- BEGIN --- Implement interface `Intersectable`
+  /**
+   * Get the line intersections as vectors with this ellipse.
+   *
+   * @method lineIntersections
+   * @instance
+   * @param {VertTuple<Vector> ray - The line/ray to intersect this ellipse with.
+   * @param {boolean} inVectorBoundsOnly - (default=false) Set to true if only intersections within the vector bounds are of interest.
+   * @returns
+   */
+  lineIntersections(ray: VertTuple<Vector>, inVectorBoundsOnly: boolean = false): Array<Vertex> {
+    // First get all line intersections from underlying ellipse.
+    const ellipseIntersections: Array<Vertex> = this.circle.lineIntersections(ray, inVectorBoundsOnly);
+    // Drop all intersection points that are not contained in the circle sectors bounds.
+    const tmpLine = new Line(this.circle.center, new Vertex());
+    return ellipseIntersections.filter((intersectionPoint: Vertex) => {
+      tmpLine.b.set(intersectionPoint);
+      const lineAngle = tmpLine.angle();
+      return this.containsAngle(geomutils.wrapMinMax(lineAngle, 0, Math.PI * 2));
+    });
+  }
+
+  /**
+   * Get all line intersections of this polygon and their tangents along the shape.
+   *
+   * This method returns all intersection tangents (as vectors) with this shape. The returned array of vectors is in no specific order.
+   *
+   * @param line
+   * @param lineIntersectionTangents
+   * @returns
+   */
+  lineIntersectionTangents(line: VertTuple<any>, inVectorBoundsOnly: boolean = false): Array<Vector> {
+    // Find the intersections of all lines plus their tangents inside the circle bounds
+    const interSectionPoints: Array<Vertex> = this.lineIntersections(line, inVectorBoundsOnly);
+    return interSectionPoints.map((vert: Vertex) => {
+      // Calculate angle
+      const lineFromCenter = new Line(this.circle.center, vert);
+      const angle: number = lineFromCenter.angle();
+      // console.log("angle", (angle / Math.PI) * 180.0);
+      // const angle = Math.random() * Math.PI * 2; // TODO
+      // Calculate tangent at angle
+      return this.circle.tangentAt(angle);
+    });
+  }
+  //--- END --- Implement interface `Intersectable`
+
   /**
    * This function should invalidate any installed listeners and invalidate this object.
    * After calling this function the object might not hold valid data any more and