js-draw 0.25.0 → 1.0.0

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

@@ -1,202 +0,0 @@
-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

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

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

@@ -1,93 +0,0 @@
-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

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