modern-path2d 0.1.7 → 0.1.8

package/dist/index.d.mts

@@ -19,27 +19,31 @@ declare class Matrix3 {
     clone(): Matrix3;
 }
 
-declare class Point2D {
+interface VectorLike {
     x: number;
     y: number;
-    static get MAX(): Point2D;
-    static get MIN(): Point2D;
+}
+declare class Vector2 {
+    x: number;
+    y: number;
+    static get MAX(): Vector2;
+    static get MIN(): Vector2;
     constructor(x?: number, y?: number);
     set(x: number, y: number): this;
-    add(point: Point2D): this;
-    sub(point: Point2D): this;
-    distanceTo(point: Point2D): number;
-    distanceToSquared(point: Point2D): number;
+    add(vec: VectorLike): this;
+    sub(vec: VectorLike): this;
+    distanceTo(vec: VectorLike): number;
+    distanceToSquared(vec: VectorLike): number;
     length(): number;
     multiplyScalar(scalar: number): this;
     divideScalar(scalar: number): this;
-    subVectors(a: Point2D, b: Point2D): this;
+    subVectors(a: VectorLike, b: VectorLike): this;
     normalize(): this;
-    lerpVectors(v1: Point2D, v2: Point2D, alpha: number): this;
-    equals(point: Point2D): boolean;
+    lerpVectors(v1: VectorLike, v2: VectorLike, alpha: number): this;
+    equals(vec: VectorLike): boolean;
     applyMatrix3(m: Matrix3): this;
-    copy(point: Point2D): this;
-    clone(): Point2D;
+    copy(vec: VectorLike): this;
+    clone(): Vector2;
 }
 
 declare class BoundingBox {
@@ -56,40 +60,40 @@ declare class BoundingBox {
     constructor(left?: number, top?: number, width?: number, height?: number);
     static from(...boxes: BoundingBox[]): BoundingBox;
     translate(tx: number, ty: number): this;
-    getCenterPoint(): Point2D;
+    getCenterPoint(): Vector2;
     clone(): BoundingBox;
     toArray(): [number, number, number, number];
 }
 
 declare class CurvePath extends Curve {
     curves: Curve[];
-    currentPoint: Point2D;
+    currentPoint: Vector2;
     autoClose: boolean;
     protected _cacheLengths: number[];
-    constructor(points?: Point2D[]);
+    constructor(points?: Vector2[]);
     addCurve(curve: Curve): this;
     closePath(): this;
-    getPoint(position: number, output?: Point2D): Point2D;
+    getPoint(position: number, output?: Vector2): Vector2;
     getLength(): number;
     updateArcLengths(): void;
     getCurveLengths(): number[];
-    getSpacedPoints(divisions?: number): Point2D[];
-    getPoints(divisions?: number): Point2D[];
-    setFromPoints(points: Point2D[]): this;
+    getSpacedPoints(divisions?: number): Vector2[];
+    getPoints(divisions?: number): Vector2[];
+    setFromPoints(points: Vector2[]): this;
     bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): this;
     lineTo(x: number, y: number): this;
     moveTo(x: number, y: number): this;
     quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): this;
     rect(x: number, y: number, w: number, h: number): this;
-    splineThru(points: Point2D[]): this;
+    splineThru(points: Vector2[]): this;
     arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, clockwise?: boolean): this;
     absarc(x: number, y: number, radius: number, startAngle: number, endAngle: number, clockwise?: boolean): this;
     ellipse(x: number, y: number, radiusX: number, radiusY: number, startAngle: number, endAngle: number, clockwise?: boolean, rotation?: number): this;
     absellipse(x: number, y: number, radiusX: number, radiusY: number, startAngle: number, endAngle: number, clockwise?: boolean, rotation?: number): this;
     getCommands(): PathCommand[];
-    getMinMax(min?: Point2D, max?: Point2D): {
-        min: Point2D;
-        max: Point2D;
+    getMinMax(min?: Vector2, max?: Vector2): {
+        min: Vector2;
+        max: Vector2;
     };
     drawTo(ctx: CanvasRenderingContext2D): this;
     copy(source: CurvePath): this;
@@ -115,12 +119,13 @@ declare class Path2D<T = any> {
     rect(x: number, y: number, w: number, h: number): this;
     addCommands(commands: PathCommand[]): this;
     addData(data: string): this;
-    splineThru(points: Point2D[]): this;
+    splineThru(points: Vector2[]): this;
     forEachCurve(cb: (curve: Curve) => void): this;
+    transformPoint(cb: (point: Vector2) => void): this;
     transform(matrix: Matrix3): this;
-    getMinMax(min?: Point2D, max?: Point2D): {
-        min: Point2D;
-        max: Point2D;
+    getMinMax(min?: Vector2, max?: Vector2): {
+        min: Vector2;
+        max: Vector2;
     };
     getBoundingBox(): BoundingBox;
     getCommands(): PathCommand[];
@@ -193,27 +198,25 @@ declare abstract class Curve {
     arcLengthDivisions: number;
     protected _cacheArcLengths?: number[];
     protected _needsUpdate: boolean;
-    abstract getPoint(t: number, output?: Point2D): Point2D;
-    getPointAt(u: number, output?: Point2D): Point2D;
-    getPoints(divisions?: number): Point2D[];
-    getSpacedPoints(divisions?: number): Point2D[];
+    abstract getPoint(t: number, output?: Vector2): Vector2;
+    getPointAt(u: number, output?: Vector2): Vector2;
+    getPoints(divisions?: number): Vector2[];
+    getSpacedPoints(divisions?: number): Vector2[];
     getLength(): number;
     getLengths(divisions?: number): number[];
     updateArcLengths(): void;
     getUtoTmapping(u: number, distance?: number): number;
-    getTangent(t: number, output?: Point2D): Point2D;
-    getTangentAt(u: number, output?: Point2D): Point2D;
+    getTangent(t: number, output?: Vector2): Vector2;
+    getTangentAt(u: number, output?: Vector2): Vector2;
     /** overrideable */
+    transformPoint(cb: (point: Vector2) => void): this;
     transform(matrix: Matrix3): this;
-    /** overrideable */
     getDivisions(divisions: number): number;
-    /** overrideable */
-    getMinMax(min?: Point2D, max?: Point2D): {
-        min: Point2D;
-        max: Point2D;
+    getMinMax(min?: Vector2, max?: Vector2): {
+        min: Vector2;
+        max: Vector2;
     };
     getBoundingBox(): BoundingBox;
-    /** overrideable */
     getCommands(): PathCommand[];
     getData(): string;
     /** overrideable */
@@ -223,31 +226,32 @@ declare abstract class Curve {
 }
 
 declare class CircleCurve extends Curve {
-    center: Point2D;
+    center: Vector2;
     radius: number;
     start: number;
     end: number;
-    constructor(center: Point2D, radius: number, start?: number, end?: number);
-    getPoint(t: number): Point2D;
-    getTangent(t: number): Point2D;
-    getNormal(t: number): Point2D;
-    getMinMax(min?: Point2D, max?: Point2D): {
-        min: Point2D;
-        max: Point2D;
+    constructor(center: Vector2, radius: number, start?: number, end?: number);
+    getPoint(t: number): Vector2;
+    getTangent(t: number): Vector2;
+    getNormal(t: number): Vector2;
+    transformPoint(cb: (point: Vector2) => void): this;
+    getMinMax(min?: Vector2, max?: Vector2): {
+        min: Vector2;
+        max: Vector2;
     };
 }
 
 declare class CubicBezierCurve extends Curve {
-    v0: Point2D;
-    v1: Point2D;
-    v2: Point2D;
-    v3: Point2D;
-    constructor(v0?: Point2D, v1?: Point2D, v2?: Point2D, v3?: Point2D);
-    getPoint(t: number, output?: Point2D): Point2D;
-    transform(matrix: Matrix3): this;
-    getMinMax(min?: Point2D, max?: Point2D): {
-        min: Point2D;
-        max: Point2D;
+    start: Vector2;
+    startControl: Vector2;
+    endControl: Vector2;
+    end: Vector2;
+    constructor(start?: Vector2, startControl?: Vector2, endControl?: Vector2, end?: Vector2);
+    getPoint(t: number, output?: Vector2): Vector2;
+    transformPoint(cb: (point: Vector2) => void): this;
+    getMinMax(min?: Vector2, max?: Vector2): {
+        min: Vector2;
+        max: Vector2;
     };
     getCommands(): PathCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
@@ -255,103 +259,105 @@ declare class CubicBezierCurve extends Curve {
 }
 
 declare class EllipseCurve extends Curve {
-    x: number;
-    y: number;
+    center: Vector2;
     radiusX: number;
     radiusY: number;
     startAngle: number;
     endAngle: number;
     clockwise: boolean;
     rotation: number;
-    constructor(x?: number, y?: number, radiusX?: number, radiusY?: number, startAngle?: number, endAngle?: number, clockwise?: boolean, rotation?: number);
-    getPoint(t: number, output?: Point2D): Point2D;
+    constructor(center?: Vector2, radiusX?: number, radiusY?: number, startAngle?: number, endAngle?: number, clockwise?: boolean, rotation?: number);
+    getPoint(t: number, output?: Vector2): Vector2;
     getDivisions(divisions?: number): number;
     getCommands(): PathCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
     transform(matrix: Matrix3): this;
-    getMinMax(min?: Point2D, max?: Point2D): {
-        min: Point2D;
-        max: Point2D;
+    transformPoint(cb: (point: Vector2) => void): this;
+    getMinMax(min?: Vector2, max?: Vector2): {
+        min: Vector2;
+        max: Vector2;
     };
     copy(source: EllipseCurve): this;
 }
 
-declare class HeartCurve extends Curve {
-    center: Point2D;
-    size: number;
-    start: number;
-    end: number;
-    curves: Curve[];
-    pointT: number;
-    constructor(center: Point2D, size: number, start?: number, end?: number);
-    getPoint(value: number): Point2D;
-    getPointAt(value: number): Point2D;
-    getCurrentLine(value: number): Curve;
-    getTangent(value: number): Point2D;
-    getNormal(value: number): Point2D;
-    transform(matrix: Matrix3): this;
-    getMinMax(min?: Point2D, max?: Point2D): {
-        min: Point2D;
-        max: Point2D;
+declare class LineCurve extends Curve {
+    start: Vector2;
+    end: Vector2;
+    constructor(start?: Vector2, end?: Vector2);
+    getPoint(t: number, output?: Vector2): Vector2;
+    getPointAt(u: number, output?: Vector2): Vector2;
+    getTangent(_t: number, output?: Vector2): Vector2;
+    getTangentAt(u: number, output?: Vector2): Vector2;
+    getNormal(t: number, output?: Vector2): Vector2;
+    transformPoint(cb: (point: Vector2) => void): this;
+    getDivisions(): number;
+    getMinMax(min?: Vector2, max?: Vector2): {
+        min: Vector2;
+        max: Vector2;
     };
     getCommands(): PathCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
+    copy(source: LineCurve): this;
 }
 
-declare class LineCurve extends Curve {
-    v1: Point2D;
-    v2: Point2D;
-    constructor(v1?: Point2D, v2?: Point2D);
-    getPoint(t: number, output?: Point2D): Point2D;
-    getPointAt(u: number, output?: Point2D): Point2D;
-    getTangent(t: number, output?: Point2D): Point2D;
-    getTangentAt(u: number, output?: Point2D): Point2D;
-    transform(matrix: Matrix3): this;
-    getDivisions(): number;
-    getMinMax(min?: Point2D, max?: Point2D): {
-        min: Point2D;
-        max: Point2D;
+declare class HeartCurve extends Curve {
+    center: Vector2;
+    size: number;
+    start: number;
+    end: number;
+    curves: (CircleCurve | LineCurve)[];
+    curveT: number;
+    constructor(center: Vector2, size: number, start?: number, end?: number);
+    update(): this;
+    getPoint(t: number): Vector2;
+    getPointAt(t: number): Vector2;
+    getCurve(t: number): CircleCurve | LineCurve;
+    getTangent(t: number): Vector2;
+    getNormal(t: number): Vector2;
+    transformPoint(cb: (point: Vector2) => void): this;
+    getMinMax(min?: Vector2, max?: Vector2): {
+        min: Vector2;
+        max: Vector2;
     };
     getCommands(): PathCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
-    copy(source: LineCurve): this;
 }
 
 declare class PloygonCurve extends Curve {
-    center: Point2D;
+    center: Vector2;
     radius: number;
-    num: number;
+    number: number;
     start: number;
     end: number;
     curves: LineCurve[];
-    points: Point2D[];
-    currentLine: LineCurve;
-    pointK: any;
-    constructor(center: Point2D, radius?: number, num?: number, start?: number, end?: number);
-    getPoint(value: number): Point2D;
-    getPointAt(value: number): Point2D;
-    getCurrentLine(value: number): LineCurve;
-    getTangent(value: number): Point2D;
-    getNormal(value: number): Point2D;
-    transform(matrix: Matrix3): this;
-    getMinMax(min?: Point2D, max?: Point2D): {
-        min: Point2D;
-        max: Point2D;
+    curveT: number;
+    points: Vector2[];
+    constructor(center: Vector2, radius?: number, number?: number, start?: number, end?: number);
+    update(): this;
+    getCurve(t: number): LineCurve;
+    getPoint(t: number, output?: Vector2): Vector2;
+    getPointAt(u: number, output?: Vector2): Vector2;
+    getTangent(t: number, output?: Vector2): Vector2;
+    getNormal(t: number, output?: Vector2): Vector2;
+    transformPoint(cb: (point: Vector2) => void): this;
+    getMinMax(min?: Vector2, max?: Vector2): {
+        min: Vector2;
+        max: Vector2;
     };
     getCommands(): PathCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
 }
 
 declare class QuadraticBezierCurve extends Curve {
-    v0: Point2D;
-    v1: Point2D;
-    v2: Point2D;
-    constructor(v0?: Point2D, v1?: Point2D, v2?: Point2D);
-    getPoint(t: number, output?: Point2D): Point2D;
-    transform(matrix: Matrix3): this;
-    getMinMax(min?: Point2D, max?: Point2D): {
-        min: Point2D;
-        max: Point2D;
+    start: Vector2;
+    control: Vector2;
+    end: Vector2;
+    constructor(start?: Vector2, control?: Vector2, end?: Vector2);
+    getPoint(t: number, output?: Vector2): Vector2;
+    transformPoint(cb: (point: Vector2) => void): this;
+    getMinMax(min?: Vector2, max?: Vector2): {
+        min: Vector2;
+        max: Vector2;
     };
     getCommands(): PathCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
@@ -359,41 +365,43 @@ declare class QuadraticBezierCurve extends Curve {
 }
 
 declare class RectangularCurve extends Curve {
-    center: Point2D;
+    center: Vector2;
     rx: number;
     aspectRatio: number;
     start: number;
     end: number;
     curves: LineCurve[];
-    pointT: number;
+    curveT: number;
     get x(): number;
     get y(): number;
     get width(): number;
     get height(): number;
-    constructor(center: Point2D, rx: number, aspectRatio?: number, start?: number, end?: number);
-    getPoint(t: number): Point2D;
-    getPointAt(u: number): Point2D;
-    getCurrentLine(t: number): LineCurve;
-    getTangent(t: number): Point2D;
-    getNormal(value: number): Point2D;
-    transform(matrix: Matrix3): this;
-    getMinMax(min?: Point2D, max?: Point2D): {
-        min: Point2D;
-        max: Point2D;
+    constructor(center: Vector2, rx: number, aspectRatio?: number, start?: number, end?: number);
+    update(): this;
+    getCurve(t: number): LineCurve;
+    getPoint(t: number, output?: Vector2): Vector2;
+    getPointAt(u: number, output?: Vector2): Vector2;
+    getTangent(t: number, output?: Vector2): Vector2;
+    getNormal(t: number, output?: Vector2): Vector2;
+    transformPoint(cb: (point: Vector2) => void): this;
+    getMinMax(min?: Vector2, max?: Vector2): {
+        min: Vector2;
+        max: Vector2;
     };
     getCommands(): PathCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
 }
 
 declare class SplineCurve extends Curve {
-    points: Point2D[];
-    constructor(points?: Point2D[]);
+    points: Vector2[];
+    constructor(points?: Vector2[]);
     getDivisions(divisions?: number): number;
-    getPoint(t: number, output?: Point2D): Point2D;
+    getPoint(t: number, output?: Vector2): Vector2;
+    transformPoint(cb: (point: Vector2) => void): this;
     copy(source: SplineCurve): this;
 }
 
 declare function parseSvgToDom(svg: string | SVGElement): SVGElement;
 declare function parseSvg(svg: string | SVGElement): Path2D[];
 
-export { BoundingBox, CircleCurve, CubicBezierCurve, Curve, CurvePath, EllipseCurve, HeartCurve, LineCurve, Matrix3, Path2D, PloygonCurve, Point2D, QuadraticBezierCurve, RectangularCurve, SplineCurve, parseSvg, parseSvgToDom };
+export { BoundingBox, CircleCurve, CubicBezierCurve, Curve, CurvePath, EllipseCurve, HeartCurve, LineCurve, Matrix3, Path2D, PloygonCurve, QuadraticBezierCurve, RectangularCurve, SplineCurve, Vector2, type VectorLike, parseSvg, parseSvgToDom };