@needle-tools/three 0.169.12 → 0.169.13

package/types/src/extras/core/Curve.d.ts

@@ -0,0 +1,162 @@
+import { Vector2 } from "../../math/Vector2.js";
+import { Vector3 } from "../../math/Vector3.js";
+
+export interface CurveJSON {
+    metadata: { version: number; type: string; generator: string };
+    arcLengthDivisions: number;
+    type: string;
+}
+
+/**
+ * An abstract base class for creating a {@link Curve} object that contains methods for interpolation
+ * @remarks
+ * For an array of Curves see {@link THREE.CurvePath | CurvePath}.
+ * @remarks
+ * This following curves inherit from THREE.Curve:
+ *
+ * **2D curves**
+ *  - {@link THREE.ArcCurve}
+ *  - {@link THREE.CubicBezierCurve}
+ *  - {@link THREE.EllipseCurve}
+ *  - {@link THREE.LineCurve}
+ *  - {@link THREE.QuadraticBezierCurve}
+ *  - {@link THREE.SplineCurve}
+ *
+ * **3D curves**
+ *  - {@link THREE.CatmullRomCurve3}
+ *  - {@link THREE.CubicBezierCurve3}
+ *  - {@link THREE.LineCurve3}
+ *  - {@link THREE.QuadraticBezierCurve3}
+ *
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/Curve | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/Curve.js | Source}
+ */
+export abstract class Curve<TVector extends Vector2 | Vector3> {
+    protected constructor();
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `Curve`
+     */
+    readonly type: string | "Curve";
+
+    /**
+     * This value determines the amount of divisions when calculating the cumulative segment lengths of a {@link Curve}
+     * via {@link .getLengths}.
+     * To ensure precision when using methods like {@link .getSpacedPoints}, it is recommended to increase {@link .arcLengthDivisions} if the {@link Curve} is very large.
+     * @defaultValue `200`
+     * @remarks Expects a `Integer`
+     */
+    arcLengthDivisions: number;
+
+    /**
+     * Returns a vector for a given position on the curve.
+     * @param t A position on the curve. Must be in the range `[ 0, 1 ]`. Expects a `Float`
+     * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created. Default `new T`.
+     */
+    getPoint(t: number, optionalTarget?: TVector): TVector;
+
+    /**
+     * Returns a vector for a given position on the {@link Curve} according to the arc length.
+     * @param u A position on the {@link Curve} according to the arc length. Must be in the range `[ 0, 1 ]`. Expects a `Float`
+     * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created. Default `new T`.
+     */
+    getPointAt(u: number, optionalTarget?: TVector): TVector;
+
+    /**
+     * Returns a set of divisions `+1` points using {@link .getPoint | getPoint(t)}.
+     * @param divisions Number of pieces to divide the {@link Curve} into. Expects a `Integer`. Default `5`
+     */
+    getPoints(divisions?: number): TVector[];
+
+    /**
+     * Returns a set of divisions `+1` equi-spaced points using {@link .getPointAt | getPointAt(u)}.
+     * @param divisions Number of pieces to divide the {@link Curve} into. Expects a `Integer`. Default `5`
+     */
+    getSpacedPoints(divisions?: number): TVector[];
+
+    /**
+     * Get total {@link Curve} arc length.
+     */
+    getLength(): number;
+
+    /**
+     * Get list of cumulative segment lengths.
+     * @param divisions Expects a `Integer`
+     */
+    getLengths(divisions?: number): number[];
+
+    /**
+     * Update the cumulative segment distance cache
+     * @remarks
+     * The method must be called every time {@link Curve} parameters are changed
+     * If an updated {@link Curve} is part of a composed {@link Curve} like {@link THREE.CurvePath | CurvePath},
+     * {@link .updateArcLengths}() must be called on the composed curve, too.
+     */
+    updateArcLengths(): void;
+
+    /**
+     * Given u in the range `[ 0, 1 ]`,
+     * @remarks
+     * `u` and `t` can then be used to give you points which are equidistant from the ends of the curve, using {@link .getPoint}.
+     * @param u Expects a `Float`
+     * @param distance Expects a `Float`
+     * @returns `t` also in the range `[ 0, 1 ]`. Expects a `Float`.
+     */
+    getUtoTmapping(u: number, distance: number): number;
+
+    /**
+     * Returns a unit vector tangent at t
+     * @remarks
+     * If the derived {@link Curve} does not implement its tangent derivation, two points a small delta apart will be used to find its gradient which seems to give a reasonable approximation.
+     * @param t A position on the curve. Must be in the range `[ 0, 1 ]`. Expects a `Float`
+     * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created.
+     */
+    getTangent(t: number, optionalTarget?: TVector): TVector;
+
+    /**
+     * Returns tangent at a point which is equidistant to the ends of the {@link Curve} from the point given in {@link .getTangent}.
+     * @param u A position on the {@link Curve} according to the arc length. Must be in the range `[ 0, 1 ]`. Expects a `Float`
+     * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created.
+     */
+    getTangentAt(u: number, optionalTarget?: TVector): TVector;
+
+    /**
+     * Generates the Frenet Frames
+     * @remarks
+     * Requires a {@link Curve} definition in 3D space
+     * Used in geometries like {@link THREE.TubeGeometry | TubeGeometry} or {@link THREE.ExtrudeGeometry | ExtrudeGeometry}.
+     * @param segments Expects a `Integer`
+     * @param closed
+     */
+    computeFrenetFrames(
+        segments: number,
+        closed?: boolean,
+    ): {
+        tangents: Vector3[];
+        normals: Vector3[];
+        binormals: Vector3[];
+    };
+
+    /**
+     * Creates a clone of this instance.
+     */
+    clone(): this;
+    /**
+     * Copies another {@link Curve} object to this instance.
+     * @param source
+     */
+    copy(source: Curve<TVector>): this;
+
+    /**
+     * Returns a JSON object representation of this instance.
+     */
+    toJSON(): CurveJSON;
+
+    /**
+     * Copies the data from the given JSON object to this instance.
+     * @param json
+     */
+    fromJSON(json: CurveJSON): this;
+}

package/types/src/extras/core/CurvePath.d.ts

@@ -0,0 +1,77 @@
+import { Vector2 } from "../../math/Vector2.js";
+import { Vector3 } from "../../math/Vector3.js";
+import { Curve, CurveJSON } from "./Curve.js";
+
+export interface CurvePathJSON extends CurveJSON {
+    autoClose: boolean;
+    curves: CurveJSON[];
+}
+
+/**
+ * Curved Path - a curve path is simply a array of connected curves, but retains the api of a curve.
+ * @remarks
+ * A {@link CurvePath} is simply an array of connected curves, but retains the api of a curve.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/CurvePath | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/CurvePath.js | Source}
+ */
+export class CurvePath<TVector extends Vector2 | Vector3> extends Curve<TVector> {
+    /**
+     * The constructor take no parameters.
+     */
+    constructor();
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `CurvePath`
+     */
+    override readonly type: string | "CurvePath";
+
+    /**
+     * The array of {@link Curve | Curves}.
+     * @defaultValue `[]`
+     */
+    curves: Array<Curve<TVector>>;
+
+    /**
+     * Whether or not to automatically close the path.
+     * @defaultValue false
+     */
+    autoClose: boolean;
+
+    /**
+     * Add a curve to the {@link .curves} array.
+     * @param curve
+     */
+    add(curve: Curve<TVector>): void;
+    /**
+     * Adds a {@link LineCurve | lineCurve} to close the path.
+     */
+    closePath(): this;
+
+    getPoint(t: number, optionalTarget?: TVector): TVector;
+
+    /**
+     * Get list of cumulative curve lengths of the curves in the {@link .curves} array.
+     */
+    getCurveLengths(): number[];
+
+    /**
+     * Returns an array of points representing a sequence of curves
+     * @remarks
+     * The `division` parameter defines the number of pieces each curve is divided into
+     * However, for optimization and quality purposes, the actual sampling resolution for each curve depends on its type
+     * For example, for a {@link THREE.LineCurve | LineCurve}, the returned number of points is always just 2.
+     * @param divisions Number of pieces to divide the curve into. Expects a `Integer`. Default `12`
+     */
+    override getPoints(divisions?: number): TVector[];
+
+    /**
+     * Returns a set of divisions `+1` equi-spaced points using {@link .getPointAt | getPointAt(u)}.
+     * @param divisions Number of pieces to divide the curve into. Expects a `Integer`. Default `40`
+     */
+    override getSpacedPoints(divisions?: number): TVector[];
+
+    toJSON(): CurvePathJSON;
+    fromJSON(json: CurvePathJSON): this;
+}

package/types/src/extras/core/Interpolations.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Used internally by {@link THREE.SplineCurve | SplineCurve}.
+ * @param t Interpolation weight. Expects a `Float`
+ * @param p0 Expects a `Float`
+ * @param p1 Expects a `Float`
+ * @param p2 Expects a `Float`
+ * @param p3 P0, p1, p2, the points defining the spline curve. Expects a `Float`
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/Interpolations | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/Interpolations.js | Source}
+ */
+declare function CatmullRom(t: number, p0: number, p1: number, p2: number, p3: number): number;
+
+/**
+ * Used internally by {@link THREE.QuadraticBezierCurve3 | QuadraticBezierCurve3} and {@link THREE.QuadraticBezierCurve | QuadraticBezierCurve}.
+ * @param t Interpolation weight. Expects a `Float`
+ * @param p0 Expects a `Float`
+ * @param p1 Expects a `Float`
+ * @param p2 P0, p1, the starting, control and end points defining the curve. Expects a `Float`
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/Interpolations | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/Interpolations.js | Source}
+ */
+declare function QuadraticBezier(t: number, p0: number, p1: number, p2: number): number;
+
+/**
+ * Used internally by {@link THREE.CubicBezierCurve3 | CubicBezierCurve3} and {@link THREE.CubicBezierCurve | CubicBezierCurve}.
+ * @param t Interpolation weight. Expects a `Float`
+ * @param p0 Expects a `Float`
+ * @param p1 Expects a `Float`
+ * @param p2 Expects a `Float`
+ * @param p3 P0, p1, p2, the starting, control(twice) and end points defining the curve. Expects a `Float`
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/Interpolations | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/Interpolations.js | Source}
+ */
+declare function CubicBezier(t: number, p0: number, p1: number, p2: number, p3: number): number;
+
+export { CatmullRom, CubicBezier, QuadraticBezier };

package/types/src/extras/core/Path.d.ts

@@ -0,0 +1,166 @@
+import { Vector2, Vector2Tuple } from "../../math/Vector2.js";
+import { CurvePath, CurvePathJSON } from "./CurvePath.js";
+
+export interface PathJSON extends CurvePathJSON {
+    currentPoint: Vector2Tuple;
+}
+
+/**
+ * A 2D {@link Path} representation.
+ * @remarks
+ * The class provides methods for creating paths and contours of 2D shapes similar to the 2D Canvas API.
+ * @example
+ * ```typescript
+ * const {@link Path} = new THREE.Path();
+ * path.lineTo(0, 0.8);
+ * path.quadraticCurveTo(0, 1, 0.2, 1);
+ * path.lineTo(1, 1);
+ * const points = path.getPoints();
+ * const geometry = new THREE.BufferGeometry().setFromPoints(points);
+ * const material = new THREE.LineBasicMaterial({
+ *     color: 0xffffff
+ * });
+ * const line = new THREE.Line(geometry, material);
+ * scene.add(line);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/Path | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/Path.js | Source}
+ */
+export class Path extends CurvePath<Vector2> {
+    /**
+     * Creates a {@link Path} from the points
+     * @remarks
+     * The first point defines the offset, then successive points are added to the {@link CurvePath.curves | curves} array as {@link LineCurve | LineCurves}.
+     * If no points are specified, an empty {@link Path} is created and the {@link .currentPoint} is set to the origin.
+     * @param points Array of {@link Vector2 | Vector2s}.
+     */
+    constructor(points?: Vector2[]);
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `Path`
+     */
+    override readonly type: string | "Path";
+
+    /**
+     * The current offset of the path. Any new {@link THREE.Curve | Curve} added will start here.
+     * @defaultValue `new THREE.Vector2()`
+     */
+    currentPoint: Vector2;
+
+    /**
+     * Adds an absolutely positioned {@link THREE.EllipseCurve | EllipseCurve} to the path.
+     * @param x Expects a `Float`
+     * @param y X, The absolute center of the arc. Expects a `Float`
+     * @param radius The radius of the arc. Expects a `Float`
+     * @param startAngle The start angle in radians. Expects a `Float`
+     * @param endAngle The end angle in radians. Expects a `Float`
+     * @param clockwise Sweep the arc clockwise. Default `false`
+     */
+    absarc(aX: number, aY: number, aRadius: number, aStartAngle: number, aEndAngle: number, aClockwise?: boolean): this;
+
+    /**
+     * Adds an absolutely positioned {@link THREE.EllipseCurve | EllipseCurve} to the path.
+     * @param x Expects a `Float`
+     * @param y X, The absolute center of the ellipse. Expects a `Float`
+     * @param xRadius The radius of the ellipse in the x axis. Expects a `Float`
+     * @param yRadius The radius of the ellipse in the y axis. Expects a `Float`
+     * @param startAngle The start angle in radians. Expects a `Float`
+     * @param endAngle The end angle in radians. Expects a `Float`
+     * @param clockwise Sweep the ellipse clockwise. Default `false`
+     * @param rotation The rotation angle of the ellipse in radians, counterclockwise from the positive X axis. Optional, Expects a `Float`. Default `0`
+     */
+    absellipse(
+        aX: number,
+        aY: number,
+        xRadius: number,
+        yRadius: number,
+        aStartAngle: number,
+        aEndAngle: number,
+        aClockwise?: boolean,
+        aRotation?: number,
+    ): this;
+
+    /**
+     * Adds an {@link THREE.EllipseCurve | EllipseCurve} to the path, positioned relative to {@link .currentPoint}.
+     * @param x Expects a `Float`
+     * @param y X, The center of the arc offset from the last call. Expects a `Float`
+     * @param radius The radius of the arc. Expects a `Float`
+     * @param startAngle The start angle in radians. Expects a `Float`
+     * @param endAngle The end angle in radians. Expects a `Float`
+     * @param clockwise Sweep the arc clockwise. Default `false`
+     */
+    arc(aX: number, aY: number, aRadius: number, aStartAngle: number, aEndAngle: number, aClockwise?: boolean): this;
+
+    /**
+     * This creates a bezier curve from {@link .currentPoint} with (cp1X, cp1Y) and (cp2X, cp2Y) as control points and updates {@link .currentPoint} to x and y.
+     * @param cp1X Expects a `Float`
+     * @param cp1Y Expects a `Float`
+     * @param cp2X Expects a `Float`
+     * @param cp2Y Expects a `Float`
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
+    bezierCurveTo(aCP1x: number, aCP1y: number, aCP2x: number, aCP2y: number, aX: number, aY: number): this;
+
+    /**
+     * Adds an {@link THREE.EllipseCurve | EllipseCurve} to the path, positioned relative to {@link .currentPoint}.
+     * @param x Expects a `Float`
+     * @param y X, The center of the ellipse offset from the last call. Expects a `Float`
+     * @param xRadius The radius of the ellipse in the x axis. Expects a `Float`
+     * @param yRadius The radius of the ellipse in the y axis. Expects a `Float`
+     * @param startAngle The start angle in radians. Expects a `Float`
+     * @param endAngle The end angle in radians. Expects a `Float`
+     * @param clockwise Sweep the ellipse clockwise. Default `false`
+     * @param rotation The rotation angle of the ellipse in radians, counterclockwise from the positive X axis. Optional, Expects a `Float`. Default `0`
+     */
+    ellipse(
+        aX: number,
+        aY: number,
+        xRadius: number,
+        yRadius: number,
+        aStartAngle: number,
+        aEndAngle: number,
+        aClockwise?: boolean,
+        aRotation?: number,
+    ): this;
+
+    /**
+     * Connects a {@link THREE.LineCurve | LineCurve} from {@link .currentPoint} to x, y onto the path.
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
+    lineTo(x: number, y: number): this;
+
+    /**
+     * Move the {@link .currentPoint} to x, y.
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
+    moveTo(x: number, y: number): this;
+
+    /**
+     * Creates a quadratic curve from {@link .currentPoint} with cpX and cpY as control point and updates {@link .currentPoint} to x and y.
+     * @param cpX Expects a `Float`
+     * @param cpY Expects a `Float`
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
+    quadraticCurveTo(aCPx: number, aCPy: number, aX: number, aY: number): this;
+
+    /**
+     * Points are added to the {@link CurvePath.curves | curves} array as {@link THREE.LineCurve | LineCurves}.
+     * @param vector2s
+     */
+    setFromPoints(vectors: Vector2[]): this;
+
+    /**
+     * Connects a new {@link THREE.SplineCurve | SplineCurve} onto the path.
+     * @param points An array of {@link Vector2 | Vector2's}
+     */
+    splineThru(pts: Vector2[]): this;
+
+    toJSON(): PathJSON;
+    fromJSON(json: PathJSON): this;
+}

package/types/src/extras/core/Shape.d.ts

@@ -0,0 +1,86 @@
+import { Vector2 } from "../../math/Vector2.js";
+import { Path, PathJSON } from "./Path.js";
+
+export interface ShapeJSON extends PathJSON {
+    uuid: string;
+    holes: PathJSON[];
+}
+
+/**
+ * Defines an arbitrary 2d {@link Shape} plane using paths with optional holes
+ * @remarks
+ * It can be used with {@link THREE.ExtrudeGeometry | ExtrudeGeometry}, {@link THREE.ShapeGeometry | ShapeGeometry}, to get points, or to get triangulated faces.
+ * @example
+ * ```typescript
+ * const heartShape = new THREE.Shape();
+ * heartShape.moveTo(25, 25);
+ * heartShape.bezierCurveTo(25, 25, 20, 0, 0, 0);
+ * heartShape.bezierCurveTo(-30, 0, -30, 35, -30, 35);
+ * heartShape.bezierCurveTo(-30, 55, -10, 77, 25, 95);
+ * heartShape.bezierCurveTo(60, 77, 80, 55, 80, 35);
+ * heartShape.bezierCurveTo(80, 35, 80, 0, 50, 0);
+ * heartShape.bezierCurveTo(35, 0, 25, 25, 25, 25);
+ * const extrudeSettings = {
+ *     depth: 8,
+ *     bevelEnabled: true,
+ *     bevelSegments: 2,
+ *     steps: 2,
+ *     bevelSize: 1,
+ *     bevelThickness: 1
+ * };
+ * const geometry = new THREE.ExtrudeGeometry(heartShape, extrudeSettings);
+ * const mesh = new THREE.Mesh(geometry, new THREE.MeshPhongMaterial());
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_shapes | geometry / shapes }
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_extrude_shapes | geometry / extrude / shapes }
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_extrude_shapes2 | geometry / extrude / shapes2 }
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/Shape | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/Shape.js | Source}
+ */
+export class Shape extends Path {
+    /**
+     * Creates a {@link Shape} from the points
+     * @remarks
+     * The first point defines the offset, then successive points are added to the {@link CurvePath.curves | curves} array as {@link THREE.LineCurve | LineCurves}.
+     * If no points are specified, an empty {@link Shape} is created and the {@link .currentPoint} is set to the origin.
+     * @param points Array of {@link Vector2 | Vector2s}.
+     */
+    constructor(points?: Vector2[]);
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `Shape`
+     */
+    override readonly type: string | "Shape";
+
+    /**
+     * {@link http://en.wikipedia.org/wiki/Universally_unique_identifier | UUID} of this object instance.
+     * @remarks This gets automatically assigned and shouldn't be edited.
+     */
+    uuid: string;
+
+    /**
+     * An array of {@link Path | paths} that define the holes in the shape.
+     * @defaultValue `[]`
+     */
+    holes: Path[];
+
+    /**
+     * Call {@link THREE.Curve.getPoints | getPoints} on the {@link Shape} and the {@link holes} array
+     * @param divisions The fineness of the result. Expects a `Integer`
+     */
+    extractPoints(divisions: number): {
+        shape: Vector2[];
+        holes: Vector2[][];
+    };
+
+    /**
+     * Get an array of {@link Vector2 | Vector2's} that represent the holes in the shape.
+     * @param divisions The fineness of the result. Expects a `Integer`
+     */
+    getPointsHoles(divisions: number): Vector2[][];
+
+    toJSON(): ShapeJSON;
+    fromJSON(json: ShapeJSON): this;
+}

package/types/src/extras/core/ShapePath.d.ts

@@ -0,0 +1,98 @@
+import { Color } from "../../math/Color.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Path } from "./Path.js";
+import { Shape } from "./Shape.js";
+
+/**
+ * This class is used to convert a series of shapes to an array of {@link THREE.Path | Path's},
+ * for example an SVG shape to a path.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/ShapePath | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/ShapePath.js | Source}
+ */
+export class ShapePath {
+    /**
+     * Creates a new {@link ShapePath}
+     * @remarks
+     * Unlike a {@link THREE.Path | Path}, no points are passed in as the {@link ShapePath} is designed to be generated after creation.
+     */
+    constructor();
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `ShapePath`
+     */
+    readonly type: "ShapePath";
+
+    /**
+     * Array of {@link THREE.Path | Path's}s.
+     * @defaultValue `[]`
+     */
+    subPaths: Path[];
+
+    /**
+     * The current {@link THREE.Path | Path} that is being generated.
+     * @defaultValue `null`
+     */
+    readonly currentPath: Path | null;
+
+    /**
+     * {@link THREE.Color | Color} of the shape, by default set to white _(0xffffff)_.
+     * @defaultValue `new THREE.Color()`
+     */
+    color: Color;
+
+    /**
+     * Starts a new {@link THREE.Path | Path} and calls {@link THREE.Path.moveTo | Path.moveTo}( x, y ) on that {@link THREE.Path | Path}
+     * @remarks
+     * Also points {@link ShapePath.currentPath | currentPath} to that {@link THREE.Path | Path}.
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
+    moveTo(x: number, y: number): this;
+
+    /**
+     * This creates a line from the {@link ShapePath.currentPath | currentPath}'s offset to X and Y and updates the offset to X and Y.
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
+    lineTo(x: number, y: number): this;
+
+    /**
+     * This creates a quadratic curve from the {@link ShapePath.currentPath | currentPath}'s
+     * offset to _x_ and _y_ with _cpX_ and _cpY_ as control point and updates the {@link ShapePath.currentPath | currentPath}'s offset to _x_ and _y_.
+     * @param cpX Expects a `Float`
+     * @param cpY Expects a `Float`
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
+    quadraticCurveTo(aCPx: number, aCPy: number, aX: number, aY: number): this;
+
+    /**
+     * This creates a bezier curve from the {@link ShapePath.currentPath | currentPath}'s
+     * offset to _x_ and _y_ with _cp1X_, _cp1Y_ and _cp2X_, _cp2Y_ as control points and
+     * updates the {@link ShapePath.currentPath | currentPath}'s offset to _x_ and _y_.
+     * @param cp1X Expects a `Float`
+     * @param cp1Y Expects a `Float`
+     * @param cp2X Expects a `Float`
+     * @param cp2Y Expects a `Float`
+     * @param x Expects a `Float`
+     * @param y Expects a `Float`
+     */
+    bezierCurveTo(aCP1x: number, aCP1y: number, aCP2x: number, aCP2y: number, aX: number, aY: number): this;
+
+    /**
+     * Connects a new {@link THREE.SplineCurve | SplineCurve} onto the {@link ShapePath.currentPath | currentPath}.
+     * @param points An array of {@link THREE.Vector2 | Vector2}s
+     */
+    splineThru(pts: Vector2[]): this;
+
+    /**
+     * Converts the {@link ShapePath.subPaths | subPaths} array into an array of Shapes
+     * @remarks
+     * By default solid shapes are defined clockwise (CW) and holes are defined counterclockwise (CCW)
+     * If isCCW is set to true, then those are flipped.
+     * @param isCCW Changes how solids and holes are generated
+     */
+    toShapes(isCCW: boolean): Shape[];
+}

package/types/src/extras/curves/ArcCurve.d.ts

@@ -0,0 +1,41 @@
+import { EllipseCurve } from "./EllipseCurve.js";
+
+/**
+ * Alias for {@link THREE.EllipseCurve | EllipseCurve}.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/curves/ArcCurve | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/curves/ArcCurve.js | Source}
+ */
+export class ArcCurve extends EllipseCurve {
+    /**
+     * This constructor creates a new {@link ArcCurve}.
+     * @param aX The X center of the ellipse. Expects a `Float`. Default is `0`.
+     * @param aY The Y center of the ellipse. Expects a `Float`. Default is `0`.
+     * @param xRadius The radius of the ellipse in the x direction. Expects a `Float`. Default is `1`.
+     * @param yRadius The radius of the ellipse in the y direction. Expects a `Float`. Default is `1`.
+     * @param aStartAngle The start angle of the curve in radians starting from the positive X axis. Default is `0`.
+     * @param aEndAngle The end angle of the curve in radians starting from the positive X axis. Default is `2 x Math.PI`.
+     * @param aClockwise Whether the ellipse is drawn clockwise. Default is `false`.
+     */
+    constructor(
+        aX?: number,
+        aY?: number,
+        aRadius?: number,
+        aStartAngle?: number,
+        aEndAngle?: number,
+        aClockwise?: boolean,
+    );
+
+    /**
+     * Read-only flag to check if a given object is of type {@link ArcCurve}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isArcCurve = true;
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `ArcCurve`
+     */
+    override readonly type: string | "ArcCurve";
+}