@js-draw/math 1.18.0 → 1.19.0

package/dist/cjs/shapes/PointShape2D.d.ts

@@ -18,7 +18,39 @@ declare class PointShape2D extends Parameterized2DShape {
     /**
      * Returns an arbitrary unit-length vector.
      */
-    normalAt(_t: number): Vec3;
+    normalAt(_t: number): {
+        readonly x: number;
+        readonly y: number;
+        readonly z: number;
+        readonly xy: {
+            x: number;
+            y: number;
+        };
+        at(idx: number): number;
+        length(): number;
+        magnitude(): number;
+        magnitudeSquared(): number;
+        squareDistanceTo(p: Vec3): number;
+        distanceTo(p: Vec3): number;
+        maximumEntryMagnitude(): number;
+        angle(): number;
+        normalized(): Vec3;
+        normalizedOrZero(): Vec3;
+        times(c: number): Vec3;
+        plus(v: Vec3): Vec3;
+        minus(v: Vec3): Vec3;
+        dot(other: Vec3): number;
+        cross(other: Vec3): Vec3;
+        scale(other: number | Vec3): Vec3;
+        orthog(): Vec3;
+        extend(distance: number, direction: Vec3): Vec3;
+        lerp(target: Vec3, fractionTo: number): Vec3;
+        zip(other: Vec3, zip: (componentInThis: number, componentInOther: number) => number): Vec3;
+        map(fn: (component: number, index: number) => number): Vec3;
+        asArray(): [number, number, number];
+        eq(other: Vec3, fuzz?: number): boolean;
+        toString(): string;
+    };
     tangentAt(_t: number): Vec3;
     splitAt(_t: number): [PointShape2D];
     nearestPointTo(_point: Point2): {

package/dist/cjs/shapes/Rect2.d.ts

@@ -57,14 +57,46 @@ export declare class Rect2 extends Abstract2DShape {
     get bottomLeft(): Vec3;
     get width(): number;
     get height(): number;
-    get center(): Vec3;
+    get center(): {
+        readonly x: number;
+        readonly y: number;
+        readonly z: number;
+        readonly xy: {
+            x: number;
+            y: number;
+        };
+        at(idx: number): number;
+        length(): number;
+        magnitude(): number;
+        magnitudeSquared(): number;
+        squareDistanceTo(p: Vec3): number;
+        distanceTo(p: Vec3): number;
+        maximumEntryMagnitude(): number;
+        angle(): number;
+        normalized(): Vec3;
+        normalizedOrZero(): Vec3;
+        times(c: number): Vec3;
+        plus(v: Vec3): Vec3;
+        minus(v: Vec3): Vec3;
+        dot(other: Vec3): number;
+        cross(other: Vec3): Vec3;
+        scale(other: number | Vec3): Vec3;
+        orthog(): Vec3;
+        extend(distance: number, direction: Vec3): Vec3;
+        lerp(target: Vec3, fractionTo: number): Vec3;
+        zip(other: Vec3, zip: (componentInThis: number, componentInOther: number) => number): Vec3;
+        map(fn: (component: number, index: number) => number): Vec3;
+        asArray(): [number, number, number];
+        eq(other: Vec3, fuzz?: number): boolean;
+        toString(): string;
+    };
     getEdges(): LineSegment2[];
     intersectsLineSegment(lineSegment: LineSegment2): Point2[];
     signedDistance(point: Vec3): number;
     getTightBoundingBox(): Rect2;
     transformedBoundingBox(affineTransform: Mat33): Rect2;
-    /** @return true iff this is equal to [other] ± fuzz */
-    eq(other: Rect2, fuzz?: number): boolean;
+    /** @return true iff this is equal to `other ± tolerance` */
+    eq(other: Rect2, tolerance?: number): boolean;
     toString(): string;
     static fromCorners(corner1: Point2, corner2: Point2): Rect2;
     static bboxOf(points: Point2[], margin?: number): Rect2;

package/dist/cjs/shapes/Rect2.js

@@ -227,9 +227,9 @@ class Rect2 extends Abstract2DShape_1.default {
     transformedBoundingBox(affineTransform) {
         return Rect2.bboxOf(this.corners.map(corner => affineTransform.transformVec2(corner)));
     }
-    /** @return true iff this is equal to [other] ± fuzz */
-    eq(other, fuzz = 0) {
-        return this.topLeft.eq(other.topLeft, fuzz) && this.size.eq(other.size, fuzz);
+    /** @return true iff this is equal to `other ± tolerance` */
+    eq(other, tolerance = 0) {
+        return this.topLeft.eq(other.topLeft, tolerance) && this.size.eq(other.size, tolerance);
     }
     toString() {
         return `Rect(point(${this.x}, ${this.y}), size(${this.w}, ${this.h}))`;

package/dist/mjs/Vec2.d.ts

@@ -1,42 +1,5 @@
-import Vec3 from './Vec3';
-/**
- * Utility functions that facilitate treating `Vec3`s as 2D vectors.
- *
- * @example
- * ```ts,runnable,console
- * import { Vec2 } from '@js-draw/math';
- * console.log(Vec2.of(1, 2));
- * ```
- */
-export declare namespace Vec2 {
-    /**
-     * Creates a `Vec2` from an x and y coordinate.
-     *
-     * For example,
-     * ```ts
-     * const v = Vec2.of(3, 4); // x=3, y=4.
-     * ```
-     */
-    const of: (x: number, y: number) => Vec2;
-    /**
-     * Creates a `Vec2` from an object containing x and y coordinates.
-     *
-     * For example,
-     * ```ts
-     * const v1 = Vec2.ofXY({ x: 3, y: 4.5 });
-     * const v2 = Vec2.ofXY({ x: -123.4, y: 1 });
-     * ```
-     */
-    const ofXY: ({ x, y }: {
-        x: number;
-        y: number;
-    }) => Vec2;
-    /** A vector of length 1 in the X direction (→). */
-    const unitX: Vec3;
-    /** A vector of length 1 in the Y direction (↑). */
-    const unitY: Vec3;
-    /** The zero vector: A vector with x=0, y=0. */
-    const zero: Vec3;
-}
+import { Vec3, Vec2 } from './Vec3';
 export type Point2 = Vec3;
 export type Vec2 = Vec3;
+export { Vec3, Vec2 };
+export default Vec2;

package/dist/mjs/Vec2.mjs

@@ -1,42 +1,6 @@
-import  Vec3  from './Vec3.mjs';
-/**
- * Utility functions that facilitate treating `Vec3`s as 2D vectors.
- *
- * @example
- * ```ts,runnable,console
- * import { Vec2 } from '@js-draw/math';
- * console.log(Vec2.of(1, 2));
- * ```
- */
-export var Vec2;
-(function (Vec2) {
-    /**
-     * Creates a `Vec2` from an x and y coordinate.
-     *
-     * For example,
-     * ```ts
-     * const v = Vec2.of(3, 4); // x=3, y=4.
-     * ```
-     */
-    Vec2.of = (x, y) => {
-        return Vec3.of(x, y, 0);
-    };
-    /**
-     * Creates a `Vec2` from an object containing x and y coordinates.
-     *
-     * For example,
-     * ```ts
-     * const v1 = Vec2.ofXY({ x: 3, y: 4.5 });
-     * const v2 = Vec2.ofXY({ x: -123.4, y: 1 });
-     * ```
-     */
-    Vec2.ofXY = ({ x, y }) => {
-        return Vec3.of(x, y, 0);
-    };
-    /** A vector of length 1 in the X direction (→). */
-    Vec2.unitX = Vec2.of(1, 0);
-    /** A vector of length 1 in the Y direction (↑). */
-    Vec2.unitY = Vec2.of(0, 1);
-    /** The zero vector: A vector with x=0, y=0. */
-    Vec2.zero = Vec2.of(0, 0);
-})(Vec2 || (Vec2 = {}));
+// Internally, we define Vec2 as a namespace within Vec3 --
+// this allows referencing Vec2s from Vec3 constructors without
+// cyclic references.
+import  { Vec3, Vec2 }  from './Vec3.mjs';
+export { Vec3, Vec2 };
+export default Vec2;

package/dist/mjs/Vec3.d.ts

@@ -17,22 +17,23 @@
  * console.log('As an array:', Vec3.unitZ.asArray());
  * ```
  */
-export declare class Vec3 {
+export interface Vec3 {
     readonly x: number;
     readonly y: number;
     readonly z: number;
-    private constructor();
-    /** Returns the x, y components of this. */
-    get xy(): {
+    /**
+     * Returns the x, y components of this.
+     * May be implemented as a getter method.
+     */
+    readonly xy: {
         x: number;
         y: number;
     };
-    /** Construct a vector from three components. */
-    static of(x: number, y: number, z: number): Vec3;
-    /** Returns this' `idx`th component. For example, `Vec3.of(1, 2, 3).at(1) → 2`. */
-    at(idx: number): number;
-    /** Alias for this.magnitude. */
+    /** Returns the vector's `idx`th component. For example, `Vec3.of(1, 2, 3).at(1) → 2`. */
+    at(i: number): number;
+    /** Alias for `.magnitude`. */
     length(): number;
+    /** Returns the length of this vector in ℝ^3. */
     magnitude(): number;
     magnitudeSquared(): number;
     /**
@@ -41,7 +42,7 @@ export declare class Vec3 {
      *
      * Equivalent to `.minus(p).magnitudeSquared()`.
      */
-    squareDistanceTo(p: Vec3): number;
+    squareDistanceTo(other: Vec3): number;
     /**
      * Interpreting this vector as a point in ℝ³, returns the distance to the point
      * `p`.
@@ -90,10 +91,17 @@ export declare class Vec3 {
     normalizedOrZero(): Vec3;
     /** @returns A copy of `this` multiplied by a scalar. */
     times(c: number): Vec3;
+    /** Performs vector addition. */
     plus(v: Vec3): Vec3;
     minus(v: Vec3): Vec3;
-    dot(other: Vec3): number;
-    cross(other: Vec3): Vec3;
+    /**
+     * Computes the scalar product between this and `v`.
+     *
+     * In particular, `a.dot(b)` is equivalent to `a.x * b.x + a.y * b.y + a.z * b.z`.
+     */
+    dot(v: Vec3): number;
+    /** Computes the cross product between this and `v` */
+    cross(v: Vec3): Vec3;
     /**
      * If `other` is a `Vec3`, multiplies `this` component-wise by `other`. Otherwise,
      * if `other is a `number`, returns the result of scalar multiplication.
@@ -154,11 +162,99 @@ export declare class Vec3 {
      * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 2.99); // → false
      * ```
      */
+    eq(other: Vec3, tolerance?: number): boolean;
+    toString(): string;
+}
+declare class Vec2Impl implements Vec3 {
+    readonly x: number;
+    readonly y: number;
+    constructor(x: number, y: number);
+    get z(): number;
+    get xy(): {
+        x: number;
+        y: number;
+    };
+    at(idx: number): number;
+    length(): number;
+    magnitude(): number;
+    magnitudeSquared(): number;
+    squareDistanceTo(p: Vec3): number;
+    distanceTo(p: Vec3): number;
+    maximumEntryMagnitude(): number;
+    angle(): number;
+    normalized(): Vec3;
+    normalizedOrZero(): Vec3;
+    times(c: number): Vec3;
+    plus(v: Vec3): Vec3;
+    minus(v: Vec3): Vec3;
+    dot(other: Vec3): number;
+    cross(other: Vec3): Vec3;
+    scale(other: Vec3 | number): Vec3;
+    orthog(): Vec3;
+    extend(distance: number, direction: Vec3): Vec3;
+    lerp(target: Vec3, fractionTo: number): Vec3;
+    zip(other: Vec3, zip: (componentInThis: number, componentInOther: number) => number): Vec3;
+    map(fn: (component: number, index: number) => number): Vec3;
+    asArray(): [number, number, number];
     eq(other: Vec3, fuzz?: number): boolean;
     toString(): string;
-    static unitX: Vec3;
-    static unitY: Vec3;
-    static unitZ: Vec3;
-    static zero: Vec3;
+}
+/**
+ * A `Vec2` is a `Vec3` optimized for working in a plane. As such, they have an
+ * always-zero `z` component.
+ *
+ * ```ts,runnable,console
+ * import { Vec2 } from '@js-draw/math';
+ * console.log(Vec2.of(1, 2));
+ * ```
+ */
+export declare namespace Vec2 {
+    /**
+     * Creates a `Vec2` from an x and y coordinate.
+     *
+     * @example
+     * ```ts,runnable,console
+     * import { Vec2 } from '@js-draw/math';
+     * const v = Vec2.of(3, 4); // x=3, y=4.
+     * ```
+     */
+    const of: (x: number, y: number) => Vec2Impl;
+    /**
+     * Creates a `Vec2` from an object containing `x` and `y` coordinates.
+     *
+     * @example
+     * ```ts,runnable,console
+     * import { Vec2 } from '@js-draw/math';
+     * const v1 = Vec2.ofXY({ x: 3, y: 4.5 });
+     * const v2 = Vec2.ofXY({ x: -123.4, y: 1 });
+     * ```
+     */
+    const ofXY: ({ x, y }: {
+        x: number;
+        y: number;
+    }) => Vec2Impl;
+    /** A vector of length 1 in the X direction (→). */
+    const unitX: Vec2Impl;
+    /** A vector of length 1 in the Y direction (↑). */
+    const unitY: Vec2Impl;
+    /** The zero vector: A vector with x=0, y=0. */
+    const zero: Vec2Impl;
+}
+export declare namespace Vec3 {
+    /**
+     * Construct a vector from three components.
+     *
+     * @example
+     * ```ts,runnable,console
+     * import { Vec3 } from '@js-draw/math';
+     * const v1 = Vec3.of(1, 2, 3);
+     * ```
+     */
+    const of: (x: number, y: number, z: number) => Vec3;
+    const unitX: Vec2Impl;
+    const unitY: Vec2Impl;
+    const zero: Vec2Impl;
+    /** A vector of length 1 in the z direction. */
+    const unitZ: Vec3;
 }
 export default Vec3;