@expofp/geometry 3.8.0

package/dist/lib/rect.js

@@ -0,0 +1,269 @@
+import { Box } from './box.js';
+import { intersectLineRect } from './intersections.js';
+import { Point } from './point.js';
+import { Polygon } from './polygon.js';
+const rot = (r) => r.rotation ?? 0;
+const elev = (r) => r.elevation ?? 0;
+/**
+ * A rectangle that may be rotated about its center (center + size + rotation + elevation; the
+ * unrotated box is not exposed). Immutable value object: readonly getters; transforms return new
+ * unless a method `target` is passed. Rotation in radians, positive = clockwise (y-down).
+ */
+export class Rect {
+    /** Marker so callers can narrow the type at runtime. */
+    isRect = true;
+    /** Internal mutable backing for the center point. */
+    _center = new Point();
+    /** Internal mutable backing for the size vector (x = width, y = height). */
+    _size = new Point();
+    /** Internal mutable rotation in radians. */
+    _rotation = 0;
+    /** Internal mutable elevation (z). */
+    _elevation = 0;
+    /**
+     * Constructs a {@link Rect} from center, size, rotation, and elevation.
+     * @param center - center point `{ x, y }`
+     * @param size - dimensions `{ x: width, y: height }`
+     * @param rotation - rotation in radians, positive = clockwise (y-down); defaults to 0
+     * @param elevation - planar elevation (z); defaults to 0
+     */
+    constructor(center, size, rotation = 0, elevation = 0) {
+        this.set(center.x, center.y, size.x, size.y, rotation, elevation);
+    }
+    /**
+     * Constructs a {@link Rect} from a min/max corner pair.
+     * @param min - minimum (top-left) corner `{ x, y }`
+     * @param max - maximum (bottom-right) corner `{ x, y }`
+     * @param rotation - rotation in radians; defaults to 0
+     * @param elevation - planar elevation (z); defaults to 0
+     * @returns a new {@link Rect} whose center is the midpoint of min/max
+     */
+    static fromMinMax(min, max, rotation = 0, elevation = 0) {
+        return new Rect({ x: (min.x + max.x) / 2, y: (min.y + max.y) / 2 }, { x: Math.abs(max.x - min.x), y: Math.abs(max.y - min.y) }, rotation, elevation);
+    }
+    /**
+     * The center point of this rect.
+     * @returns a readonly `{ x, y }` view of the center
+     */
+    get center() {
+        return this._center;
+    }
+    /**
+     * The size (width/height) of this rect. `width` aliases `x`; `height` aliases `y`.
+     * @returns a readonly point view with `width` and `height` accessors
+     */
+    get size() {
+        return this._size;
+    }
+    /**
+     * Rotation in radians (positive = clockwise, y-down).
+     * @returns the current rotation
+     */
+    get rotation() {
+        return this._rotation;
+    }
+    /**
+     * Planar elevation (z coordinate of the rect plane).
+     * @returns the current elevation
+     */
+    get elevation() {
+        return this._elevation;
+    }
+    /**
+     * Returns the four corners of this rect, rotated about its center.
+     * @returns array of four {@link Point} instances: top-left, top-right, bottom-right, bottom-left
+     */
+    corners() {
+        return rectCorners(this);
+    }
+    /**
+     * The axis-aligned bounding box that contains this (possibly rotated) rect.
+     * @returns a {@link Box} representing the AABB
+     */
+    get bounds() {
+        return rectBounds(this);
+    }
+    /**
+     * Converts this rect to a triangulated {@link Polygon}, embedding the elevation as `z`.
+     * @returns a {@link Polygon} with four vertices and two triangle indices
+     */
+    toPolygon() {
+        return rectToPolygon(this);
+    }
+    /**
+     * Returns whether a point lies inside this (possibly rotated) rect.
+     * @param p - the point to test `{ x, y }`
+     * @returns `true` if `p` is inside or on the boundary of this rect
+     */
+    containsPoint(p) {
+        return rectContainsPoint(this, p);
+    }
+    /**
+     * Returns a new rect translated by `offset`. If `target` is provided, writes into `target`
+     * and returns it instead of allocating.
+     * @param offset - translation vector `{ x, y }`
+     * @param target - optional rect to mutate in place
+     * @returns the translated rect
+     */
+    translate(offset, target) {
+        return rectTranslate(this, offset, target);
+    }
+    /**
+     * Returns a new rect with rotation increased by `angle`. If `target` is provided, writes into
+     * `target` and returns it instead of allocating.
+     * @param angle - angle to add in radians
+     * @param target - optional rect to mutate in place
+     * @returns the rotated rect
+     */
+    rotate(angle, target) {
+        return rectRotate(this, angle, target);
+    }
+    /**
+     * Returns a new rect scaled by `factor` about `origin`: the center moves toward/away from `origin`
+     * by `factor` and the size is multiplied by `factor`; rotation and elevation are preserved.
+     * If `target` is provided, writes into it instead of allocating.
+     * @param factor - uniform scale or per-axis `{ x, y }` scale
+     * @param origin - the fixed point of the scaling; defaults to this rect's center
+     * @param target - optional rect to mutate in place
+     * @returns the scaled rect
+     */
+    scale(factor, origin = this._center, target) {
+        return rectScale(this, factor, origin, target);
+    }
+    /**
+     * Points where `line` crosses this rect. Delegates to {@link intersectLineRect}.
+     * @param line - the segment
+     * @returns the intersection points
+     */
+    intersectLine(line) {
+        return intersectLineRect(line, this);
+    }
+    /**
+     * Returns a copy of this rect. If `target` is provided, writes into `target` and returns it.
+     * @param target - optional rect to mutate in place
+     * @returns the cloned rect
+     */
+    clone(target) {
+        return (target ?? new Rect(this._center, this._size)).set(this._center.x, this._center.y, this._size.x, this._size.y, this._rotation, this._elevation);
+    }
+    /**
+     * Mutates this rect in place (center, size, rotation, elevation). Prefer the immutable
+     * transforms; use this (or a transform `target`) only for hot-path reuse.
+     * @param cx - center x
+     * @param cy - center y
+     * @param sx - size x (width)
+     * @param sy - size y (height)
+     * @param rotation - rotation in radians
+     * @param elevation - planar elevation (z)
+     * @returns `this` for chaining
+     */
+    set(cx, cy, sx, sy, rotation, elevation) {
+        this._center.set(cx, cy);
+        this._size.set(sx, sy);
+        this._rotation = rotation;
+        this._elevation = elevation;
+        return this;
+    }
+}
+/**
+ * Returns the four corners of a {@link RectLike}, rotated about its center.
+ * Order: top-left, top-right, bottom-right, bottom-left.
+ * @param r - the rect-like to compute corners for
+ * @returns array of four {@link Point} instances
+ */
+export function rectCorners(r) {
+    const hx = r.size.x / 2;
+    const hy = r.size.y / 2;
+    const a = rot(r);
+    const cos = Math.cos(a);
+    const sin = Math.sin(a);
+    const cx = r.center.x;
+    const cy = r.center.y;
+    const corner = (ox, oy) => new Point(cx + ox * cos - oy * sin, cy + ox * sin + oy * cos);
+    return [corner(-hx, -hy), corner(hx, -hy), corner(hx, hy), corner(-hx, hy)];
+}
+/**
+ * Returns the axis-aligned bounding box (AABB) that contains all four corners of a
+ * {@link RectLike}.
+ * @param r - the rect-like to compute bounds for
+ * @returns a {@link Box} representing the AABB
+ */
+export function rectBounds(r) {
+    return Box.fromUnion(...rectCorners(r).map((p) => Box.fromMinMax(p, p)));
+}
+/**
+ * Converts a {@link RectLike} to a triangulated {@link Polygon} via fan-triangulation, embedding
+ * the elevation as `z` on each vertex. Rect corners form a convex quad, so
+ * {@link Polygon.fromConvexRing} is valid here.
+ * @param r - the rect-like to convert
+ * @returns a {@link Polygon} with four vertices and two triangle indices
+ */
+export function rectToPolygon(r) {
+    return Polygon.fromConvexRing(rectCorners(r), elev(r));
+}
+/**
+ * Returns whether a point lies inside a (possibly rotated) {@link RectLike} by transforming the
+ * point into the rect's local axis-aligned space.
+ * @param r - the rect-like to test against
+ * @param p - the point to test `{ x, y }`
+ * @returns `true` if `p` is inside or on the boundary of `r`
+ */
+export function rectContainsPoint(r, p) {
+    const a = -rot(r);
+    const cos = Math.cos(a);
+    const sin = Math.sin(a);
+    const dx = p.x - r.center.x;
+    const dy = p.y - r.center.y;
+    const lx = dx * cos - dy * sin;
+    const ly = dx * sin + dy * cos;
+    return Math.abs(lx) <= r.size.x / 2 && Math.abs(ly) <= r.size.y / 2;
+}
+/**
+ * Returns a new rect translated by `offset`. If `target` is provided, writes into `target` and
+ * returns it instead of allocating a new instance.
+ * @param r - the source rect-like
+ * @param offset - translation vector `{ x, y }`
+ * @param target - optional {@link Rect} to mutate in place
+ * @returns the translated rect
+ */
+export function rectTranslate(r, offset, target) {
+    const cx = r.center.x + offset.x;
+    const cy = r.center.y + offset.y;
+    return target
+        ? target.set(cx, cy, r.size.x, r.size.y, rot(r), elev(r))
+        : new Rect({ x: cx, y: cy }, r.size, rot(r), elev(r));
+}
+/**
+ * Returns a new rect with rotation increased by `angle`. If `target` is provided, writes into
+ * `target` and returns it instead of allocating a new instance.
+ * @param r - the source rect-like
+ * @param angle - angle to add in radians
+ * @param target - optional {@link Rect} to mutate in place
+ * @returns the rotated rect
+ */
+export function rectRotate(r, angle, target) {
+    return target
+        ? target.set(r.center.x, r.center.y, r.size.x, r.size.y, rot(r) + angle, elev(r))
+        : new Rect(r.center, r.size, rot(r) + angle, elev(r));
+}
+/**
+ * Returns a new rect scaled by `factor` about `origin`: the center moves toward/away from `origin`
+ * by `factor` and the size is multiplied by `factor`; rotation and elevation are preserved. If
+ * `target` is provided, writes into it instead of allocating a new instance.
+ * @param r - the source rect-like
+ * @param factor - uniform scale or per-axis `{ x, y }` scale
+ * @param origin - the fixed point of the scaling; defaults to `r`'s center
+ * @param target - optional {@link Rect} to mutate in place
+ * @returns the scaled rect
+ */
+export function rectScale(r, factor, origin = r.center, target) {
+    const fx = typeof factor === 'number' ? factor : factor.x;
+    const fy = typeof factor === 'number' ? factor : factor.y;
+    const cx = origin.x + (r.center.x - origin.x) * fx;
+    const cy = origin.y + (r.center.y - origin.y) * fy;
+    const sx = r.size.x * fx;
+    const sy = r.size.y * fy;
+    return target
+        ? target.set(cx, cy, sx, sy, rot(r), elev(r))
+        : new Rect({ x: cx, y: cy }, { x: sx, y: sy }, rot(r), elev(r));
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@expofp/geometry",
+  "version": "3.8.0",
+  "type": "module",
+  "description": "ExpoFP SDK internal: shared geometry primitives",
+  "homepage": "https://developer.expofp.com/",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@expofp/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "!**/*.map"
+  ]
+}