js-draw 0.23.1 → 0.24.1

package/dist/mjs/math/shapes/CubicBezier.mjs

@@ -0,0 +1,48 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import  BezierJSWrapper  from './BezierJSWrapper.mjs';
+import  Rect2  from './Rect2.mjs';
+/**
+ * A wrapper around [`bezier-js`](https://github.com/Pomax/bezierjs)'s cubic Bezier.
+ */
+var CubicBezier = /** @class */ (function (_super) {
+    __extends(CubicBezier, _super);
+    function CubicBezier(
+    // Start point
+    p0, 
+    // Control point 1
+    p1, 
+    // Control point 2
+    p2, 
+    // End point
+    p3) {
+        var _this = _super.call(this) || this;
+        _this.p0 = p0;
+        _this.p1 = p1;
+        _this.p2 = p2;
+        _this.p3 = p3;
+        return _this;
+    }
+    CubicBezier.prototype.getPoints = function () {
+        return [this.p0, this.p1, this.p2, this.p3];
+    };
+    /** Returns an overestimate of this shape's bounding box. */
+    CubicBezier.prototype.getLooseBoundingBox = function () {
+        return Rect2.bboxOf([this.p0, this.p1, this.p2, this.p3]);
+    };
+    return CubicBezier;
+}(BezierJSWrapper));
+export default CubicBezier;

package/dist/mjs/math/shapes/LineSegment2.d.ts

@@ -0,0 +1,70 @@
+import Mat33 from '../Mat33';
+import Rect2 from './Rect2';
+import { Vec2, Point2 } from '../Vec2';
+import Abstract2DShape from './Abstract2DShape';
+interface IntersectionResult {
+    point: Point2;
+    t: number;
+}
+/** Represents a line segment. A `LineSegment2` is immutable. */
+export default class LineSegment2 extends Abstract2DShape {
+    private readonly point1;
+    private readonly point2;
+    /**
+     * The **unit** direction vector of this line segment, from
+     * `point1` to `point2`.
+     *
+     * In other words, `direction` is `point2.minus(point1).normalized()`
+     * (perhaps except when `point1` is equal to `point2`).
+     */
+    readonly direction: Vec2;
+    /** The distance between `point1` and `point2`. */
+    readonly length: number;
+    /** The bounding box of this line segment. */
+    readonly bbox: any;
+    /** Creates a new `LineSegment2` from its endpoints. */
+    constructor(point1: Point2, point2: Point2);
+    /** Alias for `point1`. */
+    get p1(): Point2;
+    /** Alias for `point2`. */
+    get p2(): Point2;
+    /**
+     * Gets a point a distance `t` along this line.
+     *
+     * @deprecated
+     */
+    get(t: number): Point2;
+    /**
+     * Returns a point a fraction, `t`, along this line segment.
+     * Thus, `segment.at(0)` returns `segment.p1` and `segment.at(1)` returns
+     * `segment.p2`.
+     *
+     * `t` should be in `[0, 1]`.
+     */
+    at(t: number): Point2;
+    intersection(other: LineSegment2): IntersectionResult | null;
+    intersects(other: LineSegment2): boolean;
+    /**
+     * Returns the points at which this line segment intersects the
+     * given line segment.
+     *
+     * Note that {@link intersects} returns *whether* this line segment intersects another
+     * line segment. This method, by contrast, returns **the point** at which the intersection
+     * occurs, if such a point exists.
+     */
+    intersectsLineSegment(lineSegment: LineSegment2): import("../Vec3").default[];
+    closestPointTo(target: Point2): import("../Vec3").default;
+    /**
+     * Returns the distance from this line segment to `target`.
+     *
+     * Because a line segment has no interior, this signed distance is equivalent to
+     * the full distance between `target` and this line segment.
+     */
+    signedDistance(target: Point2): number;
+    /** Returns a copy of this line segment transformed by the given `affineTransfm`. */
+    transformedBy(affineTransfm: Mat33): LineSegment2;
+    /** @inheritdoc */
+    getTightBoundingBox(): Rect2;
+    toString(): string;
+}
+export {};

package/dist/mjs/math/shapes/LineSegment2.mjs

@@ -0,0 +1,202 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import  Rect2  from './Rect2.mjs';
+import  { Vec2 }  from '../Vec2.mjs';
+import  Abstract2DShape  from './Abstract2DShape.mjs';
+/** Represents a line segment. A `LineSegment2` is immutable. */
+var LineSegment2 = /** @class */ (function (_super) {
+    __extends(LineSegment2, _super);
+    /** Creates a new `LineSegment2` from its endpoints. */
+    function LineSegment2(point1, point2) {
+        var _this = _super.call(this) || this;
+        _this.point1 = point1;
+        _this.point2 = point2;
+        _this.bbox = Rect2.bboxOf([point1, point2]);
+        _this.direction = point2.minus(point1);
+        _this.length = _this.direction.magnitude();
+        // Normalize
+        if (_this.length > 0) {
+            _this.direction = _this.direction.times(1 / _this.length);
+        }
+        return _this;
+    }
+    Object.defineProperty(LineSegment2.prototype, "p1", {
+        // Accessors to make LineSegment2 compatible with bezier-js's
+        // interface
+        /** Alias for `point1`. */
+        get: function () {
+            return this.point1;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LineSegment2.prototype, "p2", {
+        /** Alias for `point2`. */
+        get: function () {
+            return this.point2;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Gets a point a distance `t` along this line.
+     *
+     * @deprecated
+     */
+    LineSegment2.prototype.get = function (t) {
+        return this.point1.plus(this.direction.times(t));
+    };
+    /**
+     * Returns a point a fraction, `t`, along this line segment.
+     * Thus, `segment.at(0)` returns `segment.p1` and `segment.at(1)` returns
+     * `segment.p2`.
+     *
+     * `t` should be in `[0, 1]`.
+     */
+    LineSegment2.prototype.at = function (t) {
+        return this.get(t * this.length);
+    };
+    LineSegment2.prototype.intersection = function (other) {
+        // We want x₁(t) = x₂(t) and y₁(t) = y₂(t)
+        // Observe that
+        // x = this.point1.x + this.direction.x · t₁
+        //   = other.point1.x + other.direction.x · t₂
+        // Thus,
+        //  t₁ = (x - this.point1.x) / this.direction.x
+        //     = (y - this.point1.y) / this.direction.y
+        // and
+        //  t₂ = (x - other.point1.x) / other.direction.x
+        // (and similarly for y)
+        //
+        // Letting o₁ₓ = this.point1.x, o₂ₓ = other.point1.x,
+        //         d₁ᵧ = this.direction.y, ...
+        //
+        // We can substitute these into the equations for y:
+        // y = o₁ᵧ + d₁ᵧ · (x - o₁ₓ) / d₁ₓ
+        //   = o₂ᵧ + d₂ᵧ · (x - o₂ₓ) / d₂ₓ
+        // ⇒ o₁ᵧ - o₂ᵧ = d₂ᵧ · (x - o₂ₓ) / d₂ₓ - d₁ᵧ · (x - o₁ₓ) / d₁ₓ
+        //            = (d₂ᵧ/d₂ₓ)(x) - (d₂ᵧ/d₂ₓ)(o₂ₓ) - (d₁ᵧ/d₁ₓ)(x) + (d₁ᵧ/d₁ₓ)(o₁ₓ)
+        //            = (x)(d₂ᵧ/d₂ₓ - d₁ᵧ/d₁ₓ) - (d₂ᵧ/d₂ₓ)(o₂ₓ) + (d₁ᵧ/d₁ₓ)(o₁ₓ)
+        // ⇒ (x)(d₂ᵧ/d₂ₓ - d₁ᵧ/d₁ₓ) = o₁ᵧ - o₂ᵧ + (d₂ᵧ/d₂ₓ)(o₂ₓ) - (d₁ᵧ/d₁ₓ)(o₁ₓ)
+        // ⇒ x = (o₁ᵧ - o₂ᵧ + (d₂ᵧ/d₂ₓ)(o₂ₓ) - (d₁ᵧ/d₁ₓ)(o₁ₓ))/(d₂ᵧ/d₂ₓ - d₁ᵧ/d₁ₓ)
+        //     = (d₁ₓd₂ₓ)(o₁ᵧ - o₂ᵧ + (d₂ᵧ/d₂ₓ)(o₂ₓ) - (d₁ᵧ/d₁ₓ)(o₁ₓ))/(d₂ᵧd₁ₓ - d₁ᵧd₂ₓ)
+        //     = ((o₁ᵧ - o₂ᵧ)((d₁ₓd₂ₓ)) + (d₂ᵧd₁ₓ)(o₂ₓ) - (d₁ᵧd₂ₓ)(o₁ₓ))/(d₂ᵧd₁ₓ - d₁ᵧd₂ₓ)
+        // ⇒ y = o₁ᵧ + d₁ᵧ · (x - o₁ₓ) / d₁ₓ = ...
+        var resultPoint, resultT;
+        if (this.direction.x === 0) {
+            // Vertical line: Where does the other have x = this.point1.x?
+            // x = o₁ₓ = o₂ₓ + d₂ₓ · (y - o₂ᵧ) / d₂ᵧ
+            // ⇒ (o₁ₓ - o₂ₓ)(d₂ᵧ/d₂ₓ) + o₂ᵧ = y
+            // Avoid division by zero
+            if (other.direction.x === 0 || this.direction.y === 0) {
+                return null;
+            }
+            var xIntersect = this.point1.x;
+            var yIntersect = (this.point1.x - other.point1.x) * other.direction.y / other.direction.x + other.point1.y;
+            resultPoint = Vec2.of(xIntersect, yIntersect);
+            resultT = (yIntersect - this.point1.y) / this.direction.y;
+        }
+        else {
+            // From above,
+            // x = ((o₁ᵧ - o₂ᵧ)(d₁ₓd₂ₓ) + (d₂ᵧd₁ₓ)(o₂ₓ) - (d₁ᵧd₂ₓ)(o₁ₓ))/(d₂ᵧd₁ₓ - d₁ᵧd₂ₓ)
+            var numerator = ((this.point1.y - other.point1.y) * this.direction.x * other.direction.x
+                + this.direction.x * other.direction.y * other.point1.x
+                - this.direction.y * other.direction.x * this.point1.x);
+            var denominator = (other.direction.y * this.direction.x
+                - this.direction.y * other.direction.x);
+            // Avoid dividing by zero. It means there is no intersection
+            if (denominator === 0) {
+                return null;
+            }
+            var xIntersect = numerator / denominator;
+            var t1 = (xIntersect - this.point1.x) / this.direction.x;
+            var yIntersect = this.point1.y + this.direction.y * t1;
+            resultPoint = Vec2.of(xIntersect, yIntersect);
+            resultT = (xIntersect - this.point1.x) / this.direction.x;
+        }
+        // Ensure the result is in this/the other segment.
+        var resultToP1 = resultPoint.minus(this.point1).magnitude();
+        var resultToP2 = resultPoint.minus(this.point2).magnitude();
+        var resultToP3 = resultPoint.minus(other.point1).magnitude();
+        var resultToP4 = resultPoint.minus(other.point2).magnitude();
+        if (resultToP1 > this.length
+            || resultToP2 > this.length
+            || resultToP3 > other.length
+            || resultToP4 > other.length) {
+            return null;
+        }
+        return {
+            point: resultPoint,
+            t: resultT,
+        };
+    };
+    LineSegment2.prototype.intersects = function (other) {
+        return this.intersection(other) !== null;
+    };
+    /**
+     * Returns the points at which this line segment intersects the
+     * given line segment.
+     *
+     * Note that {@link intersects} returns *whether* this line segment intersects another
+     * line segment. This method, by contrast, returns **the point** at which the intersection
+     * occurs, if such a point exists.
+     */
+    LineSegment2.prototype.intersectsLineSegment = function (lineSegment) {
+        var intersection = this.intersection(lineSegment);
+        if (intersection) {
+            return [intersection.point];
+        }
+        return [];
+    };
+    // Returns the closest point on this to [target]
+    LineSegment2.prototype.closestPointTo = function (target) {
+        // Distance from P1 along this' direction.
+        var projectedDistFromP1 = target.minus(this.p1).dot(this.direction);
+        var projectedDistFromP2 = this.length - projectedDistFromP1;
+        var projection = this.p1.plus(this.direction.times(projectedDistFromP1));
+        if (projectedDistFromP1 > 0 && projectedDistFromP1 < this.length) {
+            return projection;
+        }
+        if (Math.abs(projectedDistFromP2) < Math.abs(projectedDistFromP1)) {
+            return this.p2;
+        }
+        else {
+            return this.p1;
+        }
+    };
+    /**
+     * Returns the distance from this line segment to `target`.
+     *
+     * Because a line segment has no interior, this signed distance is equivalent to
+     * the full distance between `target` and this line segment.
+     */
+    LineSegment2.prototype.signedDistance = function (target) {
+        return this.closestPointTo(target).minus(target).magnitude();
+    };
+    /** Returns a copy of this line segment transformed by the given `affineTransfm`. */
+    LineSegment2.prototype.transformedBy = function (affineTransfm) {
+        return new LineSegment2(affineTransfm.transformVec2(this.p1), affineTransfm.transformVec2(this.p2));
+    };
+    /** @inheritdoc */
+    LineSegment2.prototype.getTightBoundingBox = function () {
+        return this.bbox;
+    };
+    LineSegment2.prototype.toString = function () {
+        return "LineSegment(".concat(this.p1.toString(), ", ").concat(this.p2.toString(), ")");
+    };
+    return LineSegment2;
+}(Abstract2DShape));
+export default LineSegment2;

package/dist/mjs/math/shapes/LineSegment2.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mjs/math/shapes/Path.d.ts

@@ -0,0 +1,93 @@
+import { RenderablePathSpec } from '../../rendering/renderers/AbstractRenderer';
+import RenderingStyle from '../../rendering/RenderingStyle';
+import LineSegment2 from './LineSegment2';
+import Mat33 from '../Mat33';
+import Rect2 from './Rect2';
+import { Point2 } from '../Vec2';
+import Abstract2DShape from './Abstract2DShape';
+export declare enum PathCommandType {
+    LineTo = 0,
+    MoveTo = 1,
+    CubicBezierTo = 2,
+    QuadraticBezierTo = 3
+}
+export interface CubicBezierPathCommand {
+    kind: PathCommandType.CubicBezierTo;
+    controlPoint1: Point2;
+    controlPoint2: Point2;
+    endPoint: Point2;
+}
+export interface QuadraticBezierPathCommand {
+    kind: PathCommandType.QuadraticBezierTo;
+    controlPoint: Point2;
+    endPoint: Point2;
+}
+export interface LinePathCommand {
+    kind: PathCommandType.LineTo;
+    point: Point2;
+}
+export interface MoveToPathCommand {
+    kind: PathCommandType.MoveTo;
+    point: Point2;
+}
+export type PathCommand = CubicBezierPathCommand | QuadraticBezierPathCommand | MoveToPathCommand | LinePathCommand;
+interface IntersectionResult {
+    curve: Abstract2DShape;
+    /** @internal @deprecated */
+    parameterValue?: number;
+    point: Point2;
+}
+type GeometryType = Abstract2DShape;
+type GeometryArrayType = Array<GeometryType>;
+export default class Path {
+    readonly startPoint: Point2;
+    readonly parts: PathCommand[];
+    /**
+     * A rough estimate of the bounding box of the path.
+     * A slight overestimate.
+     * See {@link getExactBBox}
+     */
+    readonly bbox: Rect2;
+    constructor(startPoint: Point2, parts: PathCommand[]);
+    getExactBBox(): Rect2;
+    private cachedGeometry;
+    get geometry(): GeometryArrayType;
+    private cachedPolylineApproximation;
+    polylineApproximation(): LineSegment2[];
+    static computeBBoxForSegment(startPoint: Point2, part: PathCommand): Rect2;
+    /**
+     * Let `S` be a closed path a distance `strokeRadius` from this path.
+     *
+     * @returns Approximate intersections of `line` with `S` using ray marching, starting from
+     * 	        both end points of `line` and each point in `additionalRaymarchStartPoints`.
+     */
+    private raymarchIntersectionWith;
+    /**
+     * Returns a list of intersections with this path. If `strokeRadius` is given,
+     * intersections are approximated with the surface `strokeRadius` away from this.
+     *
+     * If `strokeRadius > 0`, the resultant `parameterValue` has no defined value.
+     */
+    intersection(line: LineSegment2, strokeRadius?: number): IntersectionResult[];
+    private static mapPathCommand;
+    mapPoints(mapping: (point: Point2) => Point2): Path;
+    transformedBy(affineTransfm: Mat33): Path;
+    union(other: Path | null): Path;
+    private getEndPoint;
+    roughlyIntersects(rect: Rect2, strokeWidth?: number): boolean;
+    closedRoughlyIntersects(rect: Rect2): boolean;
+    static fromRect(rect: Rect2, lineWidth?: number | null): Path;
+    static fromRenderable(renderable: RenderablePathSpec): Path;
+    toRenderable(fill: RenderingStyle): RenderablePathSpec;
+    /**
+     * @returns a Path that, when rendered, looks roughly equivalent to the given path.
+     */
+    static visualEquivalent(renderablePath: RenderablePathSpec, visibleRect: Rect2): RenderablePathSpec;
+    private cachedStringVersion;
+    toString(useNonAbsCommands?: boolean): string;
+    serialize(): string;
+    static toString(startPoint: Point2, parts: PathCommand[], onlyAbsCommands?: boolean): string;
+    static fromString(pathString: string): Path;
+    static empty: Path;
+}
+export {};

package/dist/mjs/math/shapes/Path.fromString.test.d.ts

@@ -0,0 +1 @@
+export {};