js-draw 0.17.4 → 0.18.1

package/dist/src/math/Mat33.d.ts

@@ -1,118 +0,0 @@
-import { Point2, Vec2 } from './Vec2';
-import Vec3 from './Vec3';
-export type Mat33Array = [
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number,
-    number
-];
-/**
- * Represents a three dimensional linear transformation or
- * a two-dimensional affine transformation. (An affine transformation scales/rotates/shears
- * **and** translates while a linear transformation just scales/rotates/shears).
- */
-export default class Mat33 {
-    readonly a1: number;
-    readonly a2: number;
-    readonly a3: number;
-    readonly b1: number;
-    readonly b2: number;
-    readonly b3: number;
-    readonly c1: number;
-    readonly c2: number;
-    readonly c3: number;
-    private readonly rows;
-    /**
-     * Creates a matrix from inputs in the form,
-     * ```
-     * ⎡ a1 a2 a3 ⎤
-     * ⎢ b1 b2 b3 ⎥
-     * ⎣ c1 c2 c3 ⎦
-     * ```
-     */
-    constructor(a1: number, a2: number, a3: number, b1: number, b2: number, b3: number, c1: number, c2: number, c3: number);
-    /**
-     * Creates a matrix from the given rows:
-     * ```
-     *  ⎡ r1.x r1.y r1.z ⎤
-     *  ⎢ r2.x r2.y r2.z ⎥
-     *  ⎣ r3.x r3.y r3.z ⎦
-     * ```
-     */
-    static ofRows(r1: Vec3, r2: Vec3, r3: Vec3): Mat33;
-    static identity: Mat33;
-    /**
-     * Either returns the inverse of this, or, if this matrix is singular/uninvertable,
-     * returns Mat33.identity.
-     *
-     * This may cache the computed inverse and return the cached version instead of recomputing
-     * it.
-     */
-    inverse(): Mat33;
-    invertable(): boolean;
-    private cachedInverse;
-    private computeInverse;
-    transposed(): Mat33;
-    rightMul(other: Mat33): Mat33;
-    /**
-     * Applies this as an affine transformation to the given vector.
-     * Returns a transformed version of `other`.
-     */
-    transformVec2(other: Vec2): Vec2;
-    /**
-     * Applies this as a linear transformation to the given vector (doesn't translate).
-     * This is the standard way of transforming vectors in ℝ³.
-     */
-    transformVec3(other: Vec3): Vec3;
-    /** @returns true iff this is the identity matrix. */
-    isIdentity(): boolean;
-    /** Returns true iff this = other ± fuzz */
-    eq(other: Mat33, fuzz?: number): boolean;
-    toString(): string;
-    /**
-     * ```
-     * result[0] = top left element
-     * result[1] = element at row zero, column 1
-     * ...
-     * ```
-     */
-    toArray(): Mat33Array;
-    /**
-     * @example
-     * ```
-     * new Mat33(
-     *  1, 2, 3,
-     *  4, 5, 6,
-     *  7, 8, 9,
-     * ).mapEntries(component => component - 1);
-     * // → ⎡ 0, 1, 2 ⎤
-     * //   ⎢ 3, 4, 5 ⎥
-     * //   ⎣ 6, 7, 8 ⎦
-     * ```
-     */
-    mapEntries(mapping: (component: number) => number): Mat33;
-    /** Estimate the scale factor of this matrix (based on the first row). */
-    getScaleFactor(): number;
-    /** Constructs a 3x3 translation matrix (for translating `Vec2`s) */
-    static translation(amount: Vec2): Mat33;
-    static zRotation(radians: number, center?: Point2): Mat33;
-    static scaling2D(amount: number | Vec2, center?: Point2): Mat33;
-    /** @see {@link fromCSSMatrix} */
-    toCSSMatrix(): string;
-    /**
-     * Converts a CSS-form `matrix(a, b, c, d, e, f)` to a Mat33.
-     *
-     * Note that such a matrix has the form,
-     * ```
-     * ⎡ a c e ⎤
-     * ⎢ b d f ⎥
-     * ⎣ 0 0 1 ⎦
-     * ```
-     */
-    static fromCSSMatrix(cssString: string): Mat33;
-}

package/dist/src/math/Mat33.js

@@ -1,326 +0,0 @@
-import { Vec2 } from './Vec2';
-import Vec3 from './Vec3';
-/**
- * Represents a three dimensional linear transformation or
- * a two-dimensional affine transformation. (An affine transformation scales/rotates/shears
- * **and** translates while a linear transformation just scales/rotates/shears).
- */
-export default class Mat33 {
-    /**
-     * Creates a matrix from inputs in the form,
-     * ```
-     * ⎡ a1 a2 a3 ⎤
-     * ⎢ b1 b2 b3 ⎥
-     * ⎣ c1 c2 c3 ⎦
-     * ```
-     */
-    constructor(a1, a2, a3, b1, b2, b3, c1, c2, c3) {
-        this.a1 = a1;
-        this.a2 = a2;
-        this.a3 = a3;
-        this.b1 = b1;
-        this.b2 = b2;
-        this.b3 = b3;
-        this.c1 = c1;
-        this.c2 = c2;
-        this.c3 = c3;
-        this.cachedInverse = undefined;
-        this.rows = [
-            Vec3.of(a1, a2, a3),
-            Vec3.of(b1, b2, b3),
-            Vec3.of(c1, c2, c3),
-        ];
-    }
-    /**
-     * Creates a matrix from the given rows:
-     * ```
-     *  ⎡ r1.x r1.y r1.z ⎤
-     *  ⎢ r2.x r2.y r2.z ⎥
-     *  ⎣ r3.x r3.y r3.z ⎦
-     * ```
-     */
-    static ofRows(r1, r2, r3) {
-        return new Mat33(r1.x, r1.y, r1.z, r2.x, r2.y, r2.z, r3.x, r3.y, r3.z);
-    }
-    /**
-     * Either returns the inverse of this, or, if this matrix is singular/uninvertable,
-     * returns Mat33.identity.
-     *
-     * This may cache the computed inverse and return the cached version instead of recomputing
-     * it.
-     */
-    inverse() {
-        var _a;
-        return (_a = this.computeInverse()) !== null && _a !== void 0 ? _a : Mat33.identity;
-    }
-    invertable() {
-        return this.computeInverse() !== null;
-    }
-    computeInverse() {
-        if (this.cachedInverse !== undefined) {
-            return this.cachedInverse;
-        }
-        const toIdentity = [
-            this.rows[0],
-            this.rows[1],
-            this.rows[2],
-        ];
-        const toResult = [
-            Vec3.unitX,
-            Vec3.unitY,
-            Vec3.unitZ,
-        ];
-        // Convert toIdentity to the identity matrix and
-        // toResult to the inverse through elementary row operations
-        for (let cursor = 0; cursor < 3; cursor++) {
-            // Select the [cursor]th diagonal entry
-            let pivot = toIdentity[cursor].at(cursor);
-            // Don't divide by zero (treat very small numbers as zero).
-            const minDivideBy = 1e-10;
-            if (Math.abs(pivot) < minDivideBy) {
-                let swapIndex = -1;
-                // For all other rows,
-                for (let i = 1; i <= 2; i++) {
-                    const otherRowIdx = (cursor + i) % 3;
-                    if (Math.abs(toIdentity[otherRowIdx].at(cursor)) >= minDivideBy) {
-                        swapIndex = otherRowIdx;
-                        break;
-                    }
-                }
-                // Can't swap with another row?
-                if (swapIndex === -1) {
-                    this.cachedInverse = null;
-                    return null;
-                }
-                const tmpIdentityRow = toIdentity[cursor];
-                const tmpResultRow = toResult[cursor];
-                // Swap!
-                toIdentity[cursor] = toIdentity[swapIndex];
-                toResult[cursor] = toResult[swapIndex];
-                toIdentity[swapIndex] = tmpIdentityRow;
-                toResult[swapIndex] = tmpResultRow;
-                pivot = toIdentity[cursor].at(cursor);
-            }
-            // Make toIdentity[k = cursor] = 1
-            let scale = 1.0 / pivot;
-            toIdentity[cursor] = toIdentity[cursor].times(scale);
-            toResult[cursor] = toResult[cursor].times(scale);
-            const cursorToIdentityRow = toIdentity[cursor];
-            const cursorToResultRow = toResult[cursor];
-            // Make toIdentity[k ≠ cursor] = 0
-            for (let i = 1; i <= 2; i++) {
-                const otherRowIdx = (cursor + i) % 3;
-                scale = -toIdentity[otherRowIdx].at(cursor);
-                toIdentity[otherRowIdx] = toIdentity[otherRowIdx].plus(cursorToIdentityRow.times(scale));
-                toResult[otherRowIdx] = toResult[otherRowIdx].plus(cursorToResultRow.times(scale));
-            }
-        }
-        const inverse = Mat33.ofRows(toResult[0], toResult[1], toResult[2]);
-        this.cachedInverse = inverse;
-        return inverse;
-    }
-    transposed() {
-        return new Mat33(this.a1, this.b1, this.c1, this.a2, this.b2, this.c2, this.a3, this.b3, this.c3);
-    }
-    rightMul(other) {
-        other = other.transposed();
-        const at = (row, col) => {
-            return this.rows[row].dot(other.rows[col]);
-        };
-        return new Mat33(at(0, 0), at(0, 1), at(0, 2), at(1, 0), at(1, 1), at(1, 2), at(2, 0), at(2, 1), at(2, 2));
-    }
-    /**
-     * Applies this as an affine transformation to the given vector.
-     * Returns a transformed version of `other`.
-     */
-    transformVec2(other) {
-        // When transforming a Vec2, we want to use the z transformation
-        // components of this for translation:
-        //  ⎡ . . tX ⎤
-        //  ⎢ . . tY ⎥
-        //  ⎣ 0 0 1  ⎦
-        // For this, we need other's z component to be 1 (so that tX and tY
-        // are scaled by 1):
-        let intermediate = Vec3.of(other.x, other.y, 1);
-        intermediate = this.transformVec3(intermediate);
-        // Drop the z=1 to allow magnitude to work as expected
-        return Vec2.of(intermediate.x, intermediate.y);
-    }
-    /**
-     * Applies this as a linear transformation to the given vector (doesn't translate).
-     * This is the standard way of transforming vectors in ℝ³.
-     */
-    transformVec3(other) {
-        return Vec3.of(this.rows[0].dot(other), this.rows[1].dot(other), this.rows[2].dot(other));
-    }
-    /** @returns true iff this is the identity matrix. */
-    isIdentity() {
-        if (this === Mat33.identity) {
-            return true;
-        }
-        return this.eq(Mat33.identity);
-    }
-    /** Returns true iff this = other ± fuzz */
-    eq(other, fuzz = 0) {
-        for (let i = 0; i < 3; i++) {
-            if (!this.rows[i].eq(other.rows[i], fuzz)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    toString() {
-        let result = '';
-        const maxColumnLens = [0, 0, 0];
-        // Determine the longest item in each column so we can pad the others to that
-        // length.
-        for (const row of this.rows) {
-            for (let i = 0; i < 3; i++) {
-                maxColumnLens[i] = Math.max(maxColumnLens[0], `${row.at(i)}`.length);
-            }
-        }
-        for (let i = 0; i < 3; i++) {
-            if (i === 0) {
-                result += '⎡ ';
-            }
-            else if (i === 1) {
-                result += '⎢ ';
-            }
-            else {
-                result += '⎣ ';
-            }
-            // Add each component of the ith row (after padding it)
-            for (let j = 0; j < 3; j++) {
-                const val = this.rows[i].at(j).toString();
-                let padding = '';
-                for (let i = val.length; i < maxColumnLens[j]; i++) {
-                    padding += ' ';
-                }
-                result += val + ', ' + padding;
-            }
-            if (i === 0) {
-                result += ' ⎤';
-            }
-            else if (i === 1) {
-                result += ' ⎥';
-            }
-            else {
-                result += ' ⎦';
-            }
-            result += '\n';
-        }
-        return result.trimEnd();
-    }
-    /**
-     * ```
-     * result[0] = top left element
-     * result[1] = element at row zero, column 1
-     * ...
-     * ```
-     */
-    toArray() {
-        return [
-            this.a1, this.a2, this.a3,
-            this.b1, this.b2, this.b3,
-            this.c1, this.c2, this.c3,
-        ];
-    }
-    /**
-     * @example
-     * ```
-     * new Mat33(
-     *  1, 2, 3,
-     *  4, 5, 6,
-     *  7, 8, 9,
-     * ).mapEntries(component => component - 1);
-     * // → ⎡ 0, 1, 2 ⎤
-     * //   ⎢ 3, 4, 5 ⎥
-     * //   ⎣ 6, 7, 8 ⎦
-     * ```
-     */
-    mapEntries(mapping) {
-        return new Mat33(mapping(this.a1), mapping(this.a2), mapping(this.a3), mapping(this.b1), mapping(this.b2), mapping(this.b3), mapping(this.c1), mapping(this.c2), mapping(this.c3));
-    }
-    /** Estimate the scale factor of this matrix (based on the first row). */
-    getScaleFactor() {
-        return Math.hypot(this.a1, this.a2);
-    }
-    /** Constructs a 3x3 translation matrix (for translating `Vec2`s) */
-    static translation(amount) {
-        // When transforming Vec2s by a 3x3 matrix, we give the input
-        // Vec2s z = 1. As such,
-        //   outVec2.x = inVec2.x * 1 + inVec2.y * 0 + 1 * amount.x
-        //   ...
-        return new Mat33(1, 0, amount.x, 0, 1, amount.y, 0, 0, 1);
-    }
-    static zRotation(radians, center = Vec2.zero) {
-        if (radians === 0) {
-            return Mat33.identity;
-        }
-        const cos = Math.cos(radians);
-        const sin = Math.sin(radians);
-        // Translate everything so that rotation is about the origin
-        let result = Mat33.translation(center);
-        result = result.rightMul(new Mat33(cos, -sin, 0, sin, cos, 0, 0, 0, 1));
-        return result.rightMul(Mat33.translation(center.times(-1)));
-    }
-    static scaling2D(amount, center = Vec2.zero) {
-        let result = Mat33.translation(center);
-        let xAmount, yAmount;
-        if (typeof amount === 'number') {
-            xAmount = amount;
-            yAmount = amount;
-        }
-        else {
-            xAmount = amount.x;
-            yAmount = amount.y;
-        }
-        result = result.rightMul(new Mat33(xAmount, 0, 0, 0, yAmount, 0, 0, 0, 1));
-        // Translate such that [center] goes to (0, 0)
-        return result.rightMul(Mat33.translation(center.times(-1)));
-    }
-    /** @see {@link fromCSSMatrix} */
-    toCSSMatrix() {
-        return `matrix(${this.a1},${this.b1},${this.a2},${this.b2},${this.a3},${this.b3})`;
-    }
-    /**
-     * Converts a CSS-form `matrix(a, b, c, d, e, f)` to a Mat33.
-     *
-     * Note that such a matrix has the form,
-     * ```
-     * ⎡ a c e ⎤
-     * ⎢ b d f ⎥
-     * ⎣ 0 0 1 ⎦
-     * ```
-     */
-    static fromCSSMatrix(cssString) {
-        if (cssString === '' || cssString === 'none') {
-            return Mat33.identity;
-        }
-        const numberExp = '([-]?\\d*(?:\\.\\d*)?(?:[eE][-]?\\d+)?)';
-        const numberSepExp = '[, \\t\\n]';
-        const regExpSource = `^\\s*matrix\\s*\\(${[
-            // According to MDN, matrix(a,b,c,d,e,f) has form:
-            // 		⎡ a c e ⎤
-            // 		⎢ b d f ⎥
-            // 		⎣ 0 0 1 ⎦
-            numberExp, numberExp, numberExp,
-            numberExp, numberExp, numberExp, // b, d, f
-        ].join(`${numberSepExp}+`)}${numberSepExp}*\\)\\s*$`;
-        const matrixExp = new RegExp(regExpSource, 'i');
-        const match = matrixExp.exec(cssString);
-        if (!match) {
-            throw new Error(`Unsupported transformation: ${cssString}`);
-        }
-        const matrixData = match.slice(1).map(entry => parseFloat(entry));
-        const a = matrixData[0];
-        const b = matrixData[1];
-        const c = matrixData[2];
-        const d = matrixData[3];
-        const e = matrixData[4];
-        const f = matrixData[5];
-        const transform = new Mat33(a, c, e, b, d, f, 0, 0, 1);
-        return transform;
-    }
-}
-Mat33.identity = new Mat33(1, 0, 0, 0, 1, 0, 0, 0, 1);

package/dist/src/math/Path.d.ts

@@ -1,71 +0,0 @@
-import { Bezier } from 'bezier-js';
-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';
-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 | LinePathCommand | QuadraticBezierPathCommand | MoveToPathCommand;
-interface IntersectionResult {
-    curve: LineSegment2 | Bezier;
-    parameterValue: number;
-    point: Point2;
-}
-export default class Path {
-    readonly startPoint: Point2;
-    readonly parts: PathCommand[];
-    readonly bbox: Rect2;
-    constructor(startPoint: Point2, parts: PathCommand[]);
-    private cachedGeometry;
-    get geometry(): Array<LineSegment2 | Bezier>;
-    private cachedPolylineApproximation;
-    polylineApproximation(): LineSegment2[];
-    static computeBBoxForSegment(startPoint: Point2, part: PathCommand): Rect2;
-    intersection(line: LineSegment2): 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 {};