@rxflow/manhattan 0.0.1-alpha.0

package/cjs/utils/rect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rect.d.ts","sourceRoot":"","sources":["../../src/utils/rect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAQ,MAAM,aAAa,CAAA;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAC5D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AA6ClC;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,KAAK,EACb,IAAI,EAAE,SAAS,EACf,aAAa,EAAE,SAAS,EAAE,EAC1B,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,GACvB,KAAK,EAAE,CAsET"}

package/cjs/utils/rect.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRectPoints = getRectPoints;
+var _geometry = require("../geometry");
+var _grid = require("./grid");
+/**
+ * Check if a point is on the edge of a rectangle
+ */
+function isPointOnRectangleEdge(point, bbox, tolerance = 0.01) {
+  const onLeft = Math.abs(point.x - bbox.x) < tolerance;
+  const onRight = Math.abs(point.x - (bbox.x + bbox.width)) < tolerance;
+  const onTop = Math.abs(point.y - bbox.y) < tolerance;
+  const onBottom = Math.abs(point.y - (bbox.y + bbox.height)) < tolerance;
+  const withinVerticalBounds = point.y >= bbox.y - tolerance && point.y <= bbox.y + bbox.height + tolerance;
+  const withinHorizontalBounds = point.x >= bbox.x - tolerance && point.x <= bbox.x + bbox.width + tolerance;
+  return (onLeft || onRight) && withinVerticalBounds || (onTop || onBottom) && withinHorizontalBounds;
+}
+
+/**
+ * Check if a direction points outward from the rectangle edge where the anchor is located
+ */
+function isDirectionOutward(anchor, bbox, direction, tolerance = 0.01) {
+  const onLeft = Math.abs(anchor.x - bbox.x) < tolerance;
+  const onRight = Math.abs(anchor.x - (bbox.x + bbox.width)) < tolerance;
+  const onTop = Math.abs(anchor.y - bbox.y) < tolerance;
+  const onBottom = Math.abs(anchor.y - (bbox.y + bbox.height)) < tolerance;
+
+  // Only allow outward directions from the edge
+  if (onLeft && direction.x < 0) return true;
+  if (onRight && direction.x > 0) return true;
+  if (onTop && direction.y < 0) return true;
+  if (onBottom && direction.y > 0) return true;
+
+  // For corners, allow both perpendicular directions
+  if ((onLeft || onRight) && direction.x === 0) return true;
+  if ((onTop || onBottom) && direction.y === 0) return true;
+  return false;
+}
+
+/**
+ * Get points around a rectangle taking given directions into account
+ * Lines are drawn from anchor in given directions, intersections recorded
+ */
+function getRectPoints(anchor, bbox, directionList, grid, options) {
+  const precision = options.precision;
+  const directionMap = options.directionMap;
+  const centerVector = anchor.diff(bbox.getCenter());
+  const rectPoints = [];
+
+  // Check if anchor is on the edge of the bbox
+  const isOnEdge = isPointOnRectangleEdge(anchor, bbox);
+
+  // Check each allowed direction
+  for (const key of directionList) {
+    const direction = directionMap[key];
+
+    // If anchor is on edge, only consider outward directions
+    if (isOnEdge) {
+      const isOutward = isDirectionOutward(anchor, bbox, direction);
+      if (!isOutward) {
+        continue; // Skip inward directions
+      }
+    }
+
+    // Create a line that is guaranteed to intersect the bbox if bbox
+    // is in the direction even if anchor lies outside of bbox
+    const ending = new _geometry.Point(anchor.x + direction.x * (Math.abs(centerVector.x) + bbox.width), anchor.y + direction.y * (Math.abs(centerVector.y) + bbox.height));
+    const intersectionLine = new _geometry.Line(anchor, ending);
+
+    // Get the farther intersection, in case there are two
+    const intersections = intersectionLine.intersect(bbox);
+    let farthestIntersectionDistance;
+    let farthestIntersection = null;
+    for (const intersection of intersections) {
+      const distance = anchor.squaredDistance(intersection);
+      if (farthestIntersectionDistance === undefined || distance > farthestIntersectionDistance) {
+        farthestIntersectionDistance = distance;
+        farthestIntersection = intersection;
+      }
+    }
+
+    // If an intersection was found in this direction, it is our rectPoint
+    if (farthestIntersection) {
+      let target = (0, _grid.align)(farthestIntersection, grid, precision);
+
+      // If the rectPoint lies inside the bbox, offset it by one more step
+      if (bbox.containsPoint(target)) {
+        target = (0, _grid.align)(target.translate(direction.x * grid.x, direction.y * grid.y), grid, precision);
+      }
+      rectPoints.push(target);
+    }
+  }
+
+  // If anchor lies outside of bbox, add it to the array of points
+  // If anchor is on edge, don't add it - force path to start from extended points
+  if (!bbox.containsPoint(anchor) && !isOnEdge) {
+    rectPoints.push((0, _grid.align)(anchor, grid, precision));
+  }
+  return rectPoints;
+}

package/cjs/utils/route.d.ts

@@ -0,0 +1,19 @@
+import { Point } from '../geometry';
+/**
+ * Normalize a point to a unit direction vector
+ */
+export declare function normalizePoint(point: Point): Point;
+/**
+ * Get string key for a point
+ */
+export declare function getKey(point: Point): string;
+/**
+ * Calculate minimum Manhattan distance from a point to multiple anchors
+ */
+export declare function getCost(from: Point, anchors: Point[]): number;
+/**
+ * Reconstruct route by concatenating points with their parents
+ * Removes redundant points in the same direction
+ */
+export declare function reconstructRoute(parents: Map<string, Point>, points: Map<string, Point>, tailPoint: Point, startPoint: Point, endPoint: Point): Point[];
+//# sourceMappingURL=route.d.ts.map

package/cjs/utils/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../src/utils/route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAKlD;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAE3C;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,MAAM,CAW7D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,EAC3B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,EAC1B,SAAS,EAAE,KAAK,EAChB,UAAU,EAAE,KAAK,EACjB,QAAQ,EAAE,KAAK,GACd,KAAK,EAAE,CAsCT"}

package/cjs/utils/route.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCost = getCost;
+exports.getKey = getKey;
+exports.normalizePoint = normalizePoint;
+exports.reconstructRoute = reconstructRoute;
+var _geometry = require("../geometry");
+/**
+ * Normalize a point to a unit direction vector
+ */
+function normalizePoint(point) {
+  return new _geometry.Point(point.x === 0 ? 0 : Math.abs(point.x) / point.x, point.y === 0 ? 0 : Math.abs(point.y) / point.y);
+}
+
+/**
+ * Get string key for a point
+ */
+function getKey(point) {
+  return point.toString();
+}
+
+/**
+ * Calculate minimum Manhattan distance from a point to multiple anchors
+ */
+function getCost(from, anchors) {
+  let min = Infinity;
+  for (const anchor of anchors) {
+    const dist = from.manhattanDistance(anchor);
+    if (dist < min) {
+      min = dist;
+    }
+  }
+  return min;
+}
+
+/**
+ * Reconstruct route by concatenating points with their parents
+ * Removes redundant points in the same direction
+ */
+function reconstructRoute(parents, points, tailPoint, startPoint, endPoint) {
+  const route = [];
+  let prevDiff = normalizePoint(endPoint.diff(tailPoint));
+
+  // tailPoint is assumed to be aligned already
+  let currentKey = getKey(tailPoint);
+  let parent = parents.get(currentKey);
+  let point;
+  while (parent) {
+    // point is assumed to be aligned already
+    point = points.get(currentKey);
+    if (point) {
+      const diff = normalizePoint(point.diff(parent));
+      if (!diff.equals(prevDiff)) {
+        route.unshift(point);
+        prevDiff = diff;
+      }
+    }
+
+    // parent is assumed to be aligned already
+    currentKey = getKey(parent);
+    parent = parents.get(currentKey);
+  }
+
+  // leadPoint is assumed to be aligned already
+  const leadPoint = points.get(currentKey);
+  if (leadPoint) {
+    const fromDiff = normalizePoint(leadPoint.diff(startPoint));
+    if (!fromDiff.equals(prevDiff)) {
+      route.unshift(leadPoint);
+    }
+  }
+  return route;
+}

package/esm/geometry/Line.d.ts

@@ -0,0 +1,21 @@
+import { Point } from './Point';
+import { Rectangle } from './Rectangle';
+/**
+ * Line class representing a line segment
+ */
+export declare class Line {
+    start: Point;
+    end: Point;
+    constructor(start: Point, end: Point);
+    /**
+     * Calculate intersection points with a rectangle
+     * Returns an array of intersection points
+     */
+    intersect(rect: Rectangle): Point[];
+    /**
+     * Calculate intersection point between two line segments
+     * Returns null if lines don't intersect
+     */
+    private lineIntersection;
+}
+//# sourceMappingURL=Line.d.ts.map

package/esm/geometry/Line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Line.d.ts","sourceRoot":"","sources":["../../src/geometry/Line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC;;GAEG;AACH,qBAAa,IAAI;IACf,KAAK,EAAE,KAAK,CAAA;IACZ,GAAG,EAAE,KAAK,CAAA;gBAEE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK;IAKpC;;;OAGG;IACH,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG,KAAK,EAAE;IA+BnC;;;OAGG;IACH,OAAO,CAAC,gBAAgB;CA+BzB"}

package/esm/geometry/Line.js

@@ -0,0 +1,96 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { Point } from "./Point";
+/**
+ * Line class representing a line segment
+ */
+export var Line = /*#__PURE__*/function () {
+  function Line(start, end) {
+    _classCallCheck(this, Line);
+    _defineProperty(this, "start", void 0);
+    _defineProperty(this, "end", void 0);
+    this.start = start;
+    this.end = end;
+  }
+
+  /**
+   * Calculate intersection points with a rectangle
+   * Returns an array of intersection points
+   */
+  _createClass(Line, [{
+    key: "intersect",
+    value: function intersect(rect) {
+      var intersections = [];
+
+      // Define rectangle edges
+      var edges = [
+      // Top edge
+      {
+        p1: new Point(rect.x, rect.y),
+        p2: new Point(rect.x + rect.width, rect.y)
+      },
+      // Right edge
+      {
+        p1: new Point(rect.x + rect.width, rect.y),
+        p2: new Point(rect.x + rect.width, rect.y + rect.height)
+      },
+      // Bottom edge
+      {
+        p1: new Point(rect.x, rect.y + rect.height),
+        p2: new Point(rect.x + rect.width, rect.y + rect.height)
+      },
+      // Left edge
+      {
+        p1: new Point(rect.x, rect.y),
+        p2: new Point(rect.x, rect.y + rect.height)
+      }];
+
+      // Check intersection with each edge
+      for (var _i = 0, _edges = edges; _i < _edges.length; _i++) {
+        var edge = _edges[_i];
+        var intersection = this.lineIntersection(this.start, this.end, edge.p1, edge.p2);
+        if (intersection) {
+          intersections.push(intersection);
+        }
+      }
+      return intersections;
+    }
+
+    /**
+     * Calculate intersection point between two line segments
+     * Returns null if lines don't intersect
+     */
+  }, {
+    key: "lineIntersection",
+    value: function lineIntersection(p1, p2, p3, p4) {
+      var x1 = p1.x,
+        y1 = p1.y;
+      var x2 = p2.x,
+        y2 = p2.y;
+      var x3 = p3.x,
+        y3 = p3.y;
+      var x4 = p4.x,
+        y4 = p4.y;
+      var denom = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
+
+      // Lines are parallel
+      if (Math.abs(denom) < 1e-10) {
+        return null;
+      }
+      var t = ((x1 - x3) * (y3 - y4) - (y1 - y3) * (x3 - x4)) / denom;
+      var u = -((x1 - x2) * (y1 - y3) - (y1 - y2) * (x1 - x3)) / denom;
+
+      // Check if intersection is within both line segments
+      if (t >= 0 && t <= 1 && u >= 0 && u <= 1) {
+        return new Point(x1 + t * (x2 - x1), y1 + t * (y2 - y1));
+      }
+      return null;
+    }
+  }]);
+  return Line;
+}();

package/esm/geometry/Point.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Point class representing a 2D coordinate
+ */
+export declare class Point {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+    /**
+     * Create a copy of this point
+     */
+    clone(): Point;
+    /**
+     * Check if this point equals another point
+     */
+    equals(other: Point): boolean;
+    /**
+     * Translate this point by dx and dy
+     */
+    translate(dx: number, dy: number): Point;
+    /**
+     * Round coordinates to specified precision
+     */
+    round(precision: number): Point;
+    /**
+     * Calculate Manhattan distance to another point
+     */
+    manhattanDistance(other: Point): number;
+    /**
+     * Calculate angle (in degrees) from this point to another point
+     */
+    theta(other: Point): number;
+    /**
+     * Calculate the difference vector from this point to another
+     */
+    diff(other: Point): Point;
+    /**
+     * Convert point to string representation
+     */
+    toString(): string;
+    /**
+     * Snap point to grid
+     */
+    snapToGrid(gridSize: number): Point;
+    /**
+     * Calculate squared distance to another point (for performance)
+     */
+    squaredDistance(other: Point): number;
+}
+//# sourceMappingURL=Point.d.ts.map

package/esm/geometry/Point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Point.d.ts","sourceRoot":"","sources":["../../src/geometry/Point.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,KAAK;IAChB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;gBAEG,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAKhC;;OAEG;IACH,KAAK,IAAI,KAAK;IAId;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IAI7B;;OAEG;IACH,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,KAAK;IAIxC;;OAEG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK;IAQ/B;;OAEG;IACH,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IAIvC;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IAO3B;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IAIzB;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB;;OAEG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,KAAK;IAOnC;;OAEG;IACH,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;CAKtC"}

package/esm/geometry/Point.js

@@ -0,0 +1,117 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * Point class representing a 2D coordinate
+ */
+export var Point = /*#__PURE__*/function () {
+  function Point(x, y) {
+    _classCallCheck(this, Point);
+    _defineProperty(this, "x", void 0);
+    _defineProperty(this, "y", void 0);
+    this.x = x;
+    this.y = y;
+  }
+
+  /**
+   * Create a copy of this point
+   */
+  _createClass(Point, [{
+    key: "clone",
+    value: function clone() {
+      return new Point(this.x, this.y);
+    }
+
+    /**
+     * Check if this point equals another point
+     */
+  }, {
+    key: "equals",
+    value: function equals(other) {
+      return this.x === other.x && this.y === other.y;
+    }
+
+    /**
+     * Translate this point by dx and dy
+     */
+  }, {
+    key: "translate",
+    value: function translate(dx, dy) {
+      return new Point(this.x + dx, this.y + dy);
+    }
+
+    /**
+     * Round coordinates to specified precision
+     */
+  }, {
+    key: "round",
+    value: function round(precision) {
+      var factor = Math.pow(10, precision);
+      return new Point(Math.round(this.x * factor) / factor, Math.round(this.y * factor) / factor);
+    }
+
+    /**
+     * Calculate Manhattan distance to another point
+     */
+  }, {
+    key: "manhattanDistance",
+    value: function manhattanDistance(other) {
+      return Math.abs(this.x - other.x) + Math.abs(this.y - other.y);
+    }
+
+    /**
+     * Calculate angle (in degrees) from this point to another point
+     */
+  }, {
+    key: "theta",
+    value: function theta(other) {
+      var dx = other.x - this.x;
+      var dy = other.y - this.y;
+      var radians = Math.atan2(dy, dx);
+      return radians * 180 / Math.PI;
+    }
+
+    /**
+     * Calculate the difference vector from this point to another
+     */
+  }, {
+    key: "diff",
+    value: function diff(other) {
+      return new Point(other.x - this.x, other.y - this.y);
+    }
+
+    /**
+     * Convert point to string representation
+     */
+  }, {
+    key: "toString",
+    value: function toString() {
+      return "".concat(this.x, "@").concat(this.y);
+    }
+
+    /**
+     * Snap point to grid
+     */
+  }, {
+    key: "snapToGrid",
+    value: function snapToGrid(gridSize) {
+      return new Point(Math.round(this.x / gridSize) * gridSize, Math.round(this.y / gridSize) * gridSize);
+    }
+
+    /**
+     * Calculate squared distance to another point (for performance)
+     */
+  }, {
+    key: "squaredDistance",
+    value: function squaredDistance(other) {
+      var dx = other.x - this.x;
+      var dy = other.y - this.y;
+      return dx * dx + dy * dy;
+    }
+  }]);
+  return Point;
+}();

package/esm/geometry/Rectangle.d.ts

@@ -0,0 +1,41 @@
+import { Point } from './Point';
+/**
+ * Rectangle class representing a bounding box
+ */
+export declare class Rectangle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor(x: number, y: number, width: number, height: number);
+    /**
+     * Create a copy of this rectangle
+     */
+    clone(): Rectangle;
+    /**
+     * Get the center point of the rectangle
+     */
+    getCenter(): Point;
+    /**
+     * Get the origin (top-left) point of the rectangle
+     */
+    getOrigin(): Point;
+    /**
+     * Get the corner (bottom-right) point of the rectangle
+     */
+    getCorner(): Point;
+    /**
+     * Check if a point is contained within this rectangle
+     */
+    containsPoint(point: Point): boolean;
+    /**
+     * Move and expand the rectangle by a box offset
+     */
+    moveAndExpand(box: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): Rectangle;
+}
+//# sourceMappingURL=Rectangle.d.ts.map

package/esm/geometry/Rectangle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Rectangle.d.ts","sourceRoot":"","sources":["../../src/geometry/Rectangle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAE/B;;GAEG;AACH,qBAAa,SAAS;IACpB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;gBAEF,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAO/D;;OAEG;IACH,KAAK,IAAI,SAAS;IAIlB;;OAEG;IACH,SAAS,IAAI,KAAK;IAOlB;;OAEG;IACH,SAAS,IAAI,KAAK;IAIlB;;OAEG;IACH,SAAS,IAAI,KAAK;IAIlB;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IASpC;;OAEG;IACH,aAAa,CAAC,GAAG,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS;CAQvF"}

package/esm/geometry/Rectangle.js

@@ -0,0 +1,81 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { Point } from "./Point";
+
+/**
+ * Rectangle class representing a bounding box
+ */
+export var Rectangle = /*#__PURE__*/function () {
+  function Rectangle(x, y, width, height) {
+    _classCallCheck(this, Rectangle);
+    _defineProperty(this, "x", void 0);
+    _defineProperty(this, "y", void 0);
+    _defineProperty(this, "width", void 0);
+    _defineProperty(this, "height", void 0);
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+  }
+
+  /**
+   * Create a copy of this rectangle
+   */
+  _createClass(Rectangle, [{
+    key: "clone",
+    value: function clone() {
+      return new Rectangle(this.x, this.y, this.width, this.height);
+    }
+
+    /**
+     * Get the center point of the rectangle
+     */
+  }, {
+    key: "getCenter",
+    value: function getCenter() {
+      return new Point(this.x + this.width / 2, this.y + this.height / 2);
+    }
+
+    /**
+     * Get the origin (top-left) point of the rectangle
+     */
+  }, {
+    key: "getOrigin",
+    value: function getOrigin() {
+      return new Point(this.x, this.y);
+    }
+
+    /**
+     * Get the corner (bottom-right) point of the rectangle
+     */
+  }, {
+    key: "getCorner",
+    value: function getCorner() {
+      return new Point(this.x + this.width, this.y + this.height);
+    }
+
+    /**
+     * Check if a point is contained within this rectangle
+     */
+  }, {
+    key: "containsPoint",
+    value: function containsPoint(point) {
+      return point.x >= this.x && point.x <= this.x + this.width && point.y >= this.y && point.y <= this.y + this.height;
+    }
+
+    /**
+     * Move and expand the rectangle by a box offset
+     */
+  }, {
+    key: "moveAndExpand",
+    value: function moveAndExpand(box) {
+      return new Rectangle(this.x + box.x, this.y + box.y, this.width + box.width, this.height + box.height);
+    }
+  }]);
+  return Rectangle;
+}();

package/esm/geometry/index.d.ts

@@ -0,0 +1,4 @@
+export { Point } from './Point';
+export { Rectangle } from './Rectangle';
+export { Line } from './Line';
+//# sourceMappingURL=index.d.ts.map

package/esm/geometry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/geometry/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA"}

package/esm/geometry/index.js

@@ -0,0 +1,3 @@
+export { Point } from "./Point";
+export { Rectangle } from "./Rectangle";
+export { Line } from "./Line";