modern-path2d 1.4.16 → 1.5.2

package/dist/index.d.ts

@@ -90,65 +90,57 @@ interface Path2DStyle extends Path2DDrawStyle {
 
 declare function setCanvasContext(ctx: CanvasRenderingContext2D, style: Partial<Path2DStyle>): void;
 
-declare class Matrix3 {
-    elements: number[];
-    constructor(n11?: number, n12?: number, n13?: number, n21?: number, n22?: number, n23?: number, n31?: number, n32?: number, n33?: number);
-    set(n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number): this;
-    identity(): this;
-    copy(m: Matrix3): this;
-    multiply(m: Matrix3): this;
-    premultiply(m: Matrix3): this;
-    multiplyMatrices(a: Matrix3, b: Matrix3): this;
-    invert(): this;
-    transpose(): this;
-    scale(sx: number, sy: number): this;
-    rotate(theta: number): this;
-    translate(tx: number, ty: number): this;
-    makeTranslation(x: number, y: number): this;
-    makeRotation(theta: number): this;
-    makeScale(x: number, y: number): this;
-    fromArray(array: number[], offset?: number): this;
-    clone(): Matrix3;
-}
-
-interface VectorLike {
+interface Vector2Like {
     x: number;
     y: number;
 }
-declare class Vector2 {
-    x: number;
-    y: number;
+declare class Vector2 implements Vector2Like {
+    protected _x: number;
+    protected _y: number;
+    protected _onUpdate?: ((vec: Vector2) => void) | undefined;
     static get MAX(): Vector2;
     static get MIN(): Vector2;
+    static lerp(a: Vector2Like, b: Vector2Like, t: number): Vector2;
+    get width(): number;
+    set width(val: number);
+    get height(): number;
+    set height(val: number);
+    get left(): number;
+    set left(val: number);
+    get top(): number;
+    set top(val: number);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    constructor(_x?: number, _y?: number, _onUpdate?: ((vec: Vector2) => void) | undefined);
+    set(x?: number, y?: number): this;
+    add(p: Vector2Like): this;
+    sub(p: Vector2Like): this;
+    subVectors(a: Vector2Like, b: Vector2Like): this;
+    multiply(x?: number, y?: number): this;
+    divide(x?: number, y?: number): this;
+    cross(p: Vector2Like): number;
+    dot(p: Vector2Like): number;
+    rotate(rad: number, origin?: Vector2Like): this;
+    getLength(): number;
+    getAngle(): number;
+    distanceTo(p: Vector2Like): number;
+    normalize(): this;
+    copyFrom(p: Vector2Like): this;
+    copyTo<T extends Vector2>(p: T): T;
+    equals(vec: Vector2Like): boolean;
     get array(): [number, number];
-    constructor(x?: number, y?: number);
     finite(): this;
-    set(x: number, y: number): this;
-    add(vec: VectorLike): this;
-    sub(vec: VectorLike): this;
-    multiply(vec: VectorLike): this;
-    divide(vec: VectorLike): this;
-    dot(vec: VectorLike): number;
-    cross(vec: VectorLike): number;
-    rotate(a: number, target?: VectorLike): this;
-    distanceTo(vec: VectorLike): number;
-    distanceToSquared(vec: VectorLike): number;
     lengthSquared(): number;
     length(): number;
-    scale(sx: number, sy?: number, target?: VectorLike): this;
-    skew(ax: number, ay?: number, target?: VectorLike): this;
-    min(...vecs: VectorLike[]): this;
-    max(...vecs: VectorLike[]): this;
-    normalize(): this;
-    addVectors(a: VectorLike, b: VectorLike): this;
-    subVectors(a: VectorLike, b: VectorLike): this;
-    multiplyVectors(a: VectorLike, b: VectorLike): this;
-    divideVectors(a: VectorLike, b: VectorLike): this;
-    lerpVectors(v1: VectorLike, v2: VectorLike, alpha: number): this;
-    equals(vec: VectorLike): boolean;
-    applyMatrix3(m: Matrix3): this;
-    copy(vec: VectorLike): this;
-    clone(): Vector2;
+    scale(sx: number, sy?: number, origin?: Vector2Like): this;
+    skew(ax: number, ay?: number, origin?: Vector2Like): this;
+    clampMin(...pList: Vector2Like[]): this;
+    clampMax(...pList: Vector2Like[]): this;
+    clone(_onUpdate?: (vec: Vector2) => void): Vector2;
+    toJSON(): Vector2Like;
+    destroy(): void;
 }
 
 declare class BoundingBox {
@@ -171,8 +163,111 @@ declare class BoundingBox {
     clone(): BoundingBox;
 }
 
+interface TransformableObject {
+    position: {
+        x: number;
+        y: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+    };
+    skew: {
+        x: number;
+        y: number;
+    };
+    rotation: number;
+}
+/**
+ * Transform
+ *
+ * | a | c | tx|
+ * | b | d | ty|
+ * | 0 | 0 | 1 |
+ */
+declare class Transform2D {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    tx: number;
+    ty: number;
+    protected _array?: Float32Array<ArrayBuffer>;
+    constructor(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number);
+    set(a: number, b: number, c: number, d: number, tx: number, ty: number): this;
+    append(t2d: Transform2D): this;
+    appendFrom(a: Transform2D, b: Transform2D): this;
+    setTransform(x: number, y: number, pivotX: number, pivotY: number, scaleX: number, scaleY: number, rotation: number, skewX: number, skewY: number): this;
+    prepend(t2d: Transform2D): this;
+    protected _skewX?: number;
+    protected _skewY?: number;
+    protected _skewXTan: number;
+    protected _skewYTan: number;
+    skewX(x: number): this;
+    skewY(y: number): this;
+    skew(x: number, y: number): this;
+    translateX(x: number): this;
+    translateY(y: number): this;
+    translateZ(z: number): this;
+    translate3d(x: number, y: number, z: number): this;
+    translate(x: number, y: number, _z?: number): this;
+    scaleX(x: number): this;
+    scaleY(y: number): this;
+    scale3d(x: number, y: number, z?: number): this;
+    scale(x: number, y: number, _z?: number): this;
+    rotateX(x: number): this;
+    rotateY(y: number): this;
+    rotateZ(z: number): this;
+    rotate(angle: number): this;
+    rotate3d(x: number, y: number, z: number, rad: number): this;
+    protected _rotateToScale(rad: number): number;
+    protected _rotate3d(x: number, y: number, z: number, rad: number): number[];
+    decompose(pivot?: {
+        x: number;
+        y: number;
+    }, output?: TransformableObject): TransformableObject;
+    apply<P extends Vector2Like = Vector2>(pos: Vector2Like, newPos?: P): P;
+    affineInvert(): this;
+    affineInverse(): this;
+    applyAffineInverse<P extends Vector2Like = Vector2>(pos: Vector2Like, newPos?: P): P;
+    identity(): this;
+    isIdentity(): boolean;
+    copyTo(t2d: Transform2D): Transform2D;
+    copyFrom(t2d: Transform2D): this;
+    equals(t2d: Transform2D): boolean;
+    appendCssTransform(cssTransform: string, ctx?: {
+        width?: number;
+        height?: number;
+    }): this;
+    clone(): this;
+    toArray(transpose?: boolean, out?: Float32Array<ArrayBuffer>): Float32Array<ArrayBuffer>;
+    toString(): string;
+    destroy(): void;
+}
+
 declare function catmullRom(t: number, p0: number, p1: number, p2: number, p3: number): number;
 
+interface CssFunctionArg {
+    unit: string | null;
+    value: string;
+    intValue: number;
+    normalizedIntValue: number;
+    normalizedDefaultIntValue: number;
+}
+interface CssFunction {
+    name: string;
+    args: CssFunctionArg[];
+}
+interface ParseCssFunctionContext {
+    index?: number;
+    fontSize?: number;
+    width?: number;
+    height?: number;
+}
+declare function parseCssFunctions(propertyValue: string, context?: ParseCssFunctionContext): CssFunction[];
+declare function parseCssArgs(name: string, value: string, context?: ParseCssFunctionContext): CssFunctionArg[];
+declare function parseCssArg(name: string, value: string, context?: ParseCssFunctionContext): CssFunctionArg;
+
 declare function cubicBezier(t: number, p0: number, p1: number, p2: number, p3: number): number;
 
 interface FillTriangulateOptions {
@@ -196,6 +291,8 @@ declare function getAdaptiveQuadraticBezierCurvePoints(sX: number, sY: number, x
 
 declare function getDirectedArea(vertices: number[]): number;
 
+declare const PI: number;
+declare const PI_2: number;
 declare function toKebabCase(str: string): string;
 declare function getIntersectionPoint(p1: Vector2, p2: Vector2, q1: Vector2, q2: Vector2): Vector2;
 
@@ -239,7 +336,7 @@ declare abstract class Curve {
     getPointAt(u: number, output?: Vector2): Vector2;
     isClockwise(): boolean;
     getControlPointRefs(): Vector2[];
-    applyTransform(transform: Matrix3 | ((point: Vector2) => void)): this;
+    applyTransform(transform: Transform2D | ((point: Vector2) => void)): this;
     getUnevenVertices(count?: number, output?: number[]): number[];
     getSpacedVertices(count?: number, output?: number[]): number[];
     getAdaptiveVertices(output?: number[]): number[];
@@ -256,7 +353,7 @@ declare abstract class Curve {
     getTangentAt(u: number, output?: Vector2): Vector2;
     getNormal(t: number, output?: Vector2): Vector2;
     getNormalAt(u: number, output?: Vector2): Vector2;
-    getTForPoint(target: VectorLike, epsilon?: number): number;
+    getTForPoint(target: Vector2Like, epsilon?: number): number;
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
         max: Vector2;
@@ -268,7 +365,7 @@ declare abstract class Curve {
     toCommands(): Path2DCommand[];
     toData(): Path2DData;
     drawTo(ctx: CanvasRenderingContext2D): this;
-    copy(source: Curve): this;
+    copyFrom(source: Curve): this;
     clone(): this;
 }
 
@@ -298,12 +395,12 @@ declare class RoundCurve extends Curve {
     getPoint(t: number, output?: Vector2): Vector2;
     toCommands(): Path2DCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
-    applyTransform(matrix: Matrix3): this;
+    applyTransform(transform: Transform2D): this;
     getControlPointRefs(): Vector2[];
     protected _getAdaptiveVerticesByArc(output?: number[]): number[];
     protected _getAdaptiveVerticesByCircle(output?: number[]): number[];
     getAdaptiveVertices(output?: number[]): number[];
-    copy(source: RoundCurve): this;
+    copyFrom(source: RoundCurve): this;
 }
 
 declare class ArcCurve extends RoundCurve {
@@ -325,7 +422,7 @@ declare class CompositeCurve<T extends Curve = Curve> extends Curve {
     getAdaptiveVertices(output?: number[]): number[];
     strokeTriangulate(options?: StrokeTriangulateOptions): StrokeTriangulatedResult;
     getFillVertices(options?: FillTriangulateOptions): number[];
-    applyTransform(transform: Matrix3 | ((point: Vector2) => void)): this;
+    applyTransform(transform: Transform2D | ((point: Vector2) => void)): this;
     getMinMax(min?: Vector2, max?: Vector2): {
         min: Vector2;
         max: Vector2;
@@ -333,7 +430,7 @@ declare class CompositeCurve<T extends Curve = Curve> extends Curve {
     getBoundingBox(): BoundingBox;
     toCommands(): Path2DCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
-    copy(source: CompositeCurve<T>): this;
+    copyFrom(source: CompositeCurve<T>): this;
 }
 
 declare class CubicBezierCurve extends Curve {
@@ -353,7 +450,7 @@ declare class CubicBezierCurve extends Curve {
     };
     toCommands(): Path2DCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
-    copy(source: CubicBezierCurve): this;
+    copyFrom(source: CubicBezierCurve): this;
 }
 
 declare class EllipseCurve extends RoundCurve {
@@ -379,7 +476,7 @@ declare class LineCurve extends Curve {
     toCommands(): Path2DCommand[];
     getFillVertices(options?: FillTriangulateOptions): number[];
     drawTo(ctx: CanvasRenderingContext2D): this;
-    copy(source: LineCurve): this;
+    copyFrom(source: LineCurve): this;
 }
 
 declare class PloygonCurve extends CompositeCurve<LineCurve> {
@@ -392,7 +489,7 @@ declare class EquilateralPloygonCurve extends PloygonCurve {
     sideCount: number;
     constructor(cx?: number, cy?: number, radius?: number, sideCount?: number);
     update(): this;
-    copy(source: EquilateralPloygonCurve): this;
+    copyFrom(source: EquilateralPloygonCurve): this;
 }
 
 declare class QuadraticBezierCurve extends Curve {
@@ -410,7 +507,7 @@ declare class QuadraticBezierCurve extends Curve {
     };
     toCommands(): Path2DCommand[];
     drawTo(ctx: CanvasRenderingContext2D): this;
-    copy(source: QuadraticBezierCurve): this;
+    copyFrom(source: QuadraticBezierCurve): this;
 }
 
 declare class RectangleCurve extends PloygonCurve {
@@ -422,7 +519,7 @@ declare class RectangleCurve extends PloygonCurve {
     update(): this;
     drawTo(ctx: CanvasRenderingContext2D): this;
     getFillVertices(_options?: FillTriangulateOptions): number[];
-    copy(source: RectangleCurve): this;
+    copyFrom(source: RectangleCurve): this;
 }
 
 declare class RoundRectangleCurve extends RoundCurve {
@@ -434,7 +531,7 @@ declare class RoundRectangleCurve extends RoundCurve {
     constructor(x?: number, y?: number, width?: number, height?: number, radius?: number);
     update(): this;
     drawTo(ctx: CanvasRenderingContext2D): this;
-    copy(source: RoundRectangleCurve): this;
+    copyFrom(source: RoundRectangleCurve): this;
 }
 
 declare class SplineCurve extends Curve {
@@ -442,7 +539,7 @@ declare class SplineCurve extends Curve {
     constructor(points?: Vector2[]);
     getPoint(t: number, output?: Vector2): Vector2;
     getControlPointRefs(): Vector2[];
-    copy(source: SplineCurve): this;
+    copyFrom(source: SplineCurve): this;
 }
 
 declare class CurvePath extends CompositeCurve {
@@ -458,7 +555,7 @@ declare class CurvePath extends CompositeCurve {
     getSpacedVertices(count?: number, output?: number[]): number[];
     getAdaptiveVertices(output?: number[]): number[];
     getFillVertices(options?: FillTriangulateOptions): number[];
-    protected _setCurrentPoint(point: VectorLike): this;
+    protected _setCurrentPoint(point: Vector2Like): this;
     protected _connetLineTo(curve: Curve): this;
     closePath(): this;
     moveTo(x: number, y: number): this;
@@ -474,7 +571,7 @@ declare class CurvePath extends CompositeCurve {
     roundRect(x: number, y: number, width: number, height: number, radii: number): this;
     splineThru(points: Vector2[]): this;
     drawTo(ctx: CanvasRenderingContext2D): this;
-    copy(source: CurvePath): this;
+    copyFrom(source: CurvePath): this;
 }
 
 /**
@@ -512,9 +609,9 @@ declare class Path2D<T = any> extends CompositeCurve<CurvePath> {
     addCommands(commands: Path2DCommand[]): this;
     addData(data: Path2DData): this;
     splineThru(points: Vector2[]): this;
-    scale(sx: number, sy?: number, target?: VectorLike): this;
-    skew(ax: number, ay?: number, target?: VectorLike): this;
-    rotate(a: number, target?: VectorLike): this;
+    scale(sx: number, sy?: number, target?: Vector2Like): this;
+    skew(ax: number, ay?: number, target?: Vector2Like): this;
+    rotate(a: number, target?: Vector2Like): this;
     bold(b: number): this;
     getMinMax(min?: Vector2, max?: Vector2, withStyle?: boolean): {
         min: Vector2;
@@ -528,7 +625,7 @@ declare class Path2D<T = any> extends CompositeCurve<CurvePath> {
     toCommands(): Path2DCommand[];
     toData(): Path2DData;
     toSvgPathString(): string;
-    copy(source: Path2D): this;
+    copyFrom(source: Path2D): this;
 }
 
 interface TriangulatedResult {
@@ -593,5 +690,5 @@ declare function svgToDom(svg: string | SVGElement): SVGElement;
 
 declare function svgToPath2DSet(svg: string | SVGElement): Path2DSet;
 
-export { ArcCurve, BoundingBox, CompositeCurve, CubicBezierCurve, Curve, CurvePath, EllipseCurve, EquilateralPloygonCurve, FFDControlGrid, LineCurve, Matrix3, Path2D, Path2DSet, PloygonCurve, QuadraticBezierCurve, RectangleCurve, RoundRectangleCurve, SplineCurve, Vector2, applyFFD, catmullRom, cubicBezier, drawPoint, fillTriangulate, getAdaptiveCubicBezierCurvePoints, getAdaptiveQuadraticBezierCurvePoints, getDirectedArea, getIntersectionPoint, nonzeroFillRule, parseArcCommand, parsePathDataArgs, quadraticBezier, setCanvasContext, strokeTriangulate, svgPathCommandsAddToPath2D, svgPathCommandsToData, svgPathDataToCommands, svgToDom, svgToPath2DSet, toKebabCase };
-export type { DrawPointOptions, FillRule, FillTriangulateOptions, FillTriangulatedResult, LineCap, LineJoin, LineStyle, Path2DCommand, Path2DData, Path2DDrawStyle, Path2DStyle, StrokeLinecap, StrokeLinejoin, StrokeTriangulateOptions, StrokeTriangulatedResult, TriangulatedResult, VectorLike };
+export { ArcCurve, BoundingBox, CompositeCurve, CubicBezierCurve, Curve, CurvePath, EllipseCurve, EquilateralPloygonCurve, FFDControlGrid, LineCurve, PI, PI_2, Path2D, Path2DSet, PloygonCurve, QuadraticBezierCurve, RectangleCurve, RoundRectangleCurve, SplineCurve, Transform2D, Vector2, applyFFD, catmullRom, cubicBezier, drawPoint, fillTriangulate, getAdaptiveCubicBezierCurvePoints, getAdaptiveQuadraticBezierCurvePoints, getDirectedArea, getIntersectionPoint, nonzeroFillRule, parseArcCommand, parseCssArg, parseCssArgs, parseCssFunctions, parsePathDataArgs, quadraticBezier, setCanvasContext, strokeTriangulate, svgPathCommandsAddToPath2D, svgPathCommandsToData, svgPathDataToCommands, svgToDom, svgToPath2DSet, toKebabCase };
+export type { CssFunction, CssFunctionArg, DrawPointOptions, FillRule, FillTriangulateOptions, FillTriangulatedResult, LineCap, LineJoin, LineStyle, ParseCssFunctionContext, Path2DCommand, Path2DData, Path2DDrawStyle, Path2DStyle, StrokeLinecap, StrokeLinejoin, StrokeTriangulateOptions, StrokeTriangulatedResult, TransformableObject, TriangulatedResult, Vector2Like };