@types/three 0.150.1 → 0.151.0

three/examples/jsm/nodes/geometry/RangeNode.d.ts

@@ -1,5 +1,6 @@
 import { Color, Vector2, Vector3, Vector4 } from '../../../../src/Three';
 import Node from '../core/Node';
+import NodeBuilder from '../core/NodeBuilder';
 
 export type RangeModeBound = number | Color | Vector2 | Vector3 | Vector4;
 
@@ -8,5 +9,5 @@ export default class RangeNode extends Node {
     max: RangeModeBound;
 
     constructor(min: RangeModeBound, max: RangeModeBound);
-    getVectorLength(): number;
+    getVectorLength(builder: NodeBuilder): number;
 }

three/examples/jsm/nodes/lighting/PointLightNode.d.ts

@@ -0,0 +1,10 @@
+import AnalyticLightNode from './AnalyticLightNode';
+import Node from '../core/Node';
+import { PointLight } from '../../../../src/Three';
+
+export default class PointLightNode extends AnalyticLightNode<PointLight> {
+    cutoffDistanceNode: Node;
+    decayExponentNode: Node;
+
+    constructor(light?: PointLight | null);
+}

three/examples/jsm/nodes/lighting/SpotLightNode.d.ts

@@ -0,0 +1,15 @@
+import AnalyticLightNode from './AnalyticLightNode';
+import Node from '../core/Node';
+import { SpotLight } from '../../../../src/Three';
+
+export default class PointLightNode extends AnalyticLightNode<SpotLight> {
+    directionNode: Node;
+
+    coneCosNode: Node;
+    penumbraCosNode: Node;
+
+    cutoffDistanceNode: Node;
+    decayExponentNode: Node;
+
+    constructor(light?: SpotLight | null);
+}

three/examples/jsm/nodes/math/MathNode.d.ts

@@ -24,7 +24,7 @@ export type MathNodeMethod1 =
     | typeof MathNode.SIGN
     | typeof MathNode.LENGTH
     | typeof MathNode.NEGATE
-    | typeof MathNode.INVERT
+    | typeof MathNode.ONE_MINUS
     | typeof MathNode.DFDX
     | typeof MathNode.DFDY
     | typeof MathNode.ROUND;
@@ -76,7 +76,7 @@ export default class MathNode extends TempNode {
     static SIGN: 'sign';
     static LENGTH: 'length';
     static NEGATE: 'negate';
-    static INVERT: 'invert';
+    static ONE_MINUS: 'oneMinus';
     static DFDX: 'dFdx';
     static DFDY: 'dFdy';
     static ROUND: 'round';

three/examples/jsm/nodes/shadernode/ShaderNodeBaseElements.d.ts

@@ -50,7 +50,7 @@ import {
     UserDataNode,
     UVNode,
     VarNode,
-    VaryNode,
+    VaryingNode,
 } from '../Nodes';
 import StorageBufferNode from '../accessors/StorageBufferNode';
 import NodeCache from '../core/NodeCache';
@@ -130,7 +130,7 @@ export function fn<P extends FunctionNodeArguments>(
 export const instanceIndex: Swizzable<InstanceIndexNode>;
 export function label(node: NodeRepresentation, name?: string): Swizzable<VarNode>;
 export function temp(node: NodeRepresentation, name?: string): Swizzable<VarNode>;
-export function vary(node: NodeRepresentation, name?: string): Swizzable<VaryNode>;
+export function vary(node: NodeRepresentation, name?: string): Swizzable<VaryingNode>;
 
 // accesors
 

three/examples/jsm/objects/{GroundProjectedEnv.d.ts → GroundProjectedSkybox.d.ts}

@@ -1,6 +1,6 @@
 import { Mesh, IcosahedronGeometry, ShaderMaterial, Texture } from '../../../src/Three';
 
-export class GroundProjectedEnv extends Mesh<IcosahedronGeometry, ShaderMaterial> {
+export class GroundProjectedSkybox extends Mesh<IcosahedronGeometry, ShaderMaterial> {
     constructor(texture: Texture, options?: { height?: number; radius?: number });
 
     set radius(radius: number);

three/examples/jsm/postprocessing/Pass.d.ts

@@ -2,6 +2,8 @@ import { Material, WebGLRenderer, WebGLRenderTarget } from '../../../src/Three';
 
 export class Pass {
     constructor();
+
+    isPass: boolean;
     enabled: boolean;
     needsSwap: boolean;
     clear: boolean;

three/examples/jsm/renderers/CSS2DRenderer.d.ts

@@ -1,8 +1,9 @@
-import { Object3D, Scene, Camera } from '../../../src/Three';
+import { Object3D, Scene, Camera, Vector2 } from '../../../src/Three';
 
 export class CSS2DObject extends Object3D {
     constructor(element: HTMLElement);
     element: HTMLElement;
+    center: Vector2;
 
     onBeforeRender: (renderer: unknown, scene: Scene, camera: Camera) => void;
     onAfterRender: (renderer: unknown, scene: Scene, camera: Camera) => void;

three/examples/jsm/renderers/webgl/nodes/WebGLNodeBuilder.d.ts

@@ -12,7 +12,6 @@ export class WebGLNodeBuilder extends NodeBuilder {
     );
 
     addSlot(shaderStage: NodeShaderStageOption, slotNode: SlotNode): Node;
-    addFlowCode(code: string): string;
 
     getTexture(textureProperty: string, uvSnippet: string): string;
     getTextureBias(textureProperty: string, uvSnippet: string, biasSnippet: string): string;

three/examples/jsm/utils/BufferGeometryUtils.d.ts

@@ -11,8 +11,8 @@ import {
 } from '../../../src/Three';
 
 export function deepCloneAttribute(attribute: BufferAttribute): BufferAttribute;
-export function mergeBufferGeometries(geometries: BufferGeometry[], useGroups?: boolean): BufferGeometry;
-export function mergeBufferAttributes(attributes: BufferAttribute[]): BufferAttribute;
+export function mergeGeometries(geometries: BufferGeometry[], useGroups?: boolean): BufferGeometry;
+export function mergeAttributes(attributes: BufferAttribute[]): BufferAttribute;
 export function interleaveAttributes(attributes: BufferAttribute[]): InterleavedBufferAttribute;
 export function estimateBytesUsed(geometry: BufferGeometry): number;
 export function mergeVertices(geometry: BufferGeometry, tolerance?: number): BufferGeometry;
@@ -34,3 +34,13 @@ export function deinterleaveGeometry(geometry: BufferGeometry): void;
  * @param creaseAngle The crease angle.
  */
 export function toCreasedNormals(geometry: BufferGeometry, creaseAngle?: number): BufferGeometry;
+
+/**
+ * @deprecated Use mergeGeometries instead.
+ */
+export function mergeBufferGeometries(geometries: BufferGeometry[], useGroups?: boolean): BufferGeometry;
+
+/**
+ * @deprecated Use mergeAttributes instead.
+ */
+export function mergeBufferAttributes(attributes: BufferAttribute[]): BufferAttribute;

three/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for three 0.150
+// Type definitions for three 0.151
 // Project: https://threejs.org/
 // Definitions by: Josh Ellis <https://github.com/joshuaellis>
 //                 Nathan Bierema <https://github.com/Methuselah96>

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.150.1",
+    "version": "0.151.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -30,7 +30,7 @@
         "fflate": "~0.6.9",
         "lil-gui": "~0.17.0"
     },
-    "typesPublisherContentHash": "c7ff42de666a86340964d8f399b86ddfa5b1abfa546b40ede1e3385f993d5903",
+    "typesPublisherContentHash": "d8fac10d09ead80aa5112cb6407ef75e354363f34bdd002bfb12b3c5d40cb691",
     "typeScriptVersion": "4.4",
     "exports": {
         ".": {

three/src/Three.d.ts

@@ -3,7 +3,6 @@
  */
 export * from './constants';
 export * from './Three.Legacy';
-export * from './utils';
 /**
  * Animation
  */
@@ -66,6 +65,7 @@ export * from './extras/core/Path';
 export * from './extras/core/ShapePath';
 export * from './extras/core/CurvePath';
 export * from './extras/core/Curve';
+export * from './extras/core/Interpolations';
 export * as DataUtils from './extras/DataUtils';
 export * from './extras/ImageUtils';
 export * from './extras/ShapeUtils';

three/src/core/Raycaster.d.ts

@@ -28,6 +28,7 @@ export interface Intersection<TIntersected extends Object3D = Object3D> {
     object: TIntersected;
     uv?: Vector2 | undefined;
     uv2?: Vector2 | undefined;
+    normal?: Vector3;
     /** The index number of the instance where the ray intersects the {@link THREE.InstancedMesh | InstancedMesh } */
     instanceId?: number | undefined;
 }

three/src/extras/DataUtils.d.ts

@@ -1,2 +1,15 @@
+/**
+ * Returns a half precision floating point value from the given single precision floating point value.
+ * @param val A single precision floating point value.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/DataUtils | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/DataUtils.js | Source}
+ */
 export function toHalfFloat(val: number): number;
+
+/**
+ * Returns a single precision floating point value from the given half precision floating point value.
+ * @param val A half precision floating point value.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/DataUtils | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/DataUtils.js | Source}
+ */
 export function fromHalfFloat(val: number): number;

three/src/extras/Earcut.d.ts

@@ -1,3 +1,15 @@
+/**
+ * An implementation of the {@link Earcut} polygon triangulation algorithm
+ * @remarks
+ * The code is a port of {@link https://github.com/mapbox/earcut | mapbox/earcut}.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/Earcut | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/Earcut.js | Source}
+ */
 export const Earcut: {
+    /**
+     * Triangulates the given shape definition by returning an array of triangles
+     * @remarks
+     * A triangle is defined by three consecutive integers representing vertex indices.
+     */
     triangulate(data: number[], holeIndices?: number[], dim?: number): number[];
 };

three/src/extras/ImageUtils.d.ts

@@ -1,33 +1,33 @@
 import { Mapping } from '../constants';
 import { Texture } from '../textures/Texture';
 
+/**
+ * A class containing utility functions for images.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/ImageUtils | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/ImageUtils.js | Source}
+ */
 export namespace ImageUtils {
-    function getDataURL(image: any): string;
-
     /**
-     * @deprecated
+     * Returns a data URI containing a representation of the given image.
+     * @param image The image object.
      */
-    let crossOrigin: string;
+    function getDataURL(
+        image: HTMLImageElement | HTMLCanvasElement | CanvasImageSource | ImageBitmap | ImageData,
+    ): string;
 
     /**
-     * @deprecated Use {@link TextureLoader THREE.TextureLoader()} instead.
+     * Converts the given sRGB image data to linear color space.
+     * @param image
      */
-    function loadTexture(
-        url: string,
-        mapping?: Mapping,
-        onLoad?: (texture: Texture) => void,
-        onError?: (message: string) => void,
-    ): Texture;
+    function sRGBToLinear(image: HTMLImageElement | HTMLCanvasElement | ImageBitmap): HTMLCanvasElement;
 
     /**
-     * @deprecated Use {@link CubeTextureLoader THREE.CubeTextureLoader()} instead.
+     * Converts the given sRGB image data to linear color space.
+     * @param image
      */
-    function loadTextureCube(
-        array: string[],
-        mapping?: Mapping,
-        onLoad?: (texture: Texture) => void,
-        onError?: (message: string) => void,
-    ): Texture;
-
-    function sRGBToLinear(image: any): HTMLCanvasElement | { data: number[]; width: number; height: number };
+    function sRGBToLinear(image: ImageData): {
+        data: ImageData['data'];
+        width: ImageData['width'];
+        height: ImageData['height'];
+    };
 }

three/src/extras/PMREMGenerator.d.ts

@@ -4,12 +4,78 @@ import { Texture } from '../textures/Texture';
 import { CubeTexture } from '../textures/CubeTexture';
 import { Scene } from '../scenes/Scene';
 
+/**
+ * This class generates a Prefiltered, Mipmapped Radiance Environment Map (PMREM) from a cubeMap environment texture.
+ * @remarks
+ * This allows different levels of blur to be quickly accessed based on material roughness
+ * Unlike a traditional mipmap chain, it only goes down to the LOD_MIN level (above), and then creates extra even more filtered 'mips' at the same LOD_MIN resolution,
+ * associated with higher roughness levels
+ * In this way we maintain resolution to smoothly interpolate diffuse lighting while limiting sampling computation.
+ * @remarks
+ * Note: The minimum {@link THREE.MeshStandardMaterial | MeshStandardMaterial}'s roughness depends on the size of the provided texture
+ * If your render has small dimensions or the shiny parts have a lot of curvature, you may still be able to get away with a smaller texture size.
+ *
+ * | texture size | minimum roughness  |
+ * |--------------|--------------------|
+ * | 16           | 0.21               |
+ * | 32           | 0.15               |
+ * | 64           | 0.11               |
+ * | 128          | 0.076              |
+ * | 256          | 0.054              |
+ * | 512          | 0.038              |
+ * | 1024         | 0.027              |
+ *
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/PMREMGenerator | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/PMREMGenerator.js | Source}
+ */
 export class PMREMGenerator {
+    /**
+     * This constructor creates a new PMREMGenerator.
+     * @param renderer
+     */
     constructor(renderer: WebGLRenderer);
+
+    /**
+     * Generates a PMREM from a supplied Scene, which can be faster than using an image if networking bandwidth is low
+     * @remarks
+     * Optional near and far planes ensure the scene is rendered in its entirety (the cubeCamera is placed at the origin).
+     * @param scene The given scene.
+     * @param sigma Specifies a blur radius in radians to be applied to the scene before PMREM generation. Default `0`.
+     * @param near The near plane value. Default `0.1`.
+     * @param far The far plane value. Default `100`.
+     */
     fromScene(scene: Scene, sigma?: number, near?: number, far?: number): WebGLRenderTarget;
+
+    /**
+     * Generates a PMREM from an equirectangular texture.
+     * @param equirectangular The equirectangular texture.
+     */
     fromEquirectangular(equirectangular: Texture, renderTarget?: WebGLRenderTarget | null): WebGLRenderTarget;
+
+    /**
+     * Generates a PMREM from an cubemap texture.
+     * @param cubemap The cubemap texture.
+     */
     fromCubemap(cubemap: CubeTexture, renderTarget?: WebGLRenderTarget | null): WebGLRenderTarget;
+
+    /**
+     * Pre-compiles the cubemap shader
+     * @remarks
+     * You can get faster start-up by invoking this method during your texture's network fetch for increased concurrency.
+     */
     compileCubemapShader(): void;
+
+    /**
+     * Pre-compiles the equirectangular shader
+     * @remarks
+     * You can get faster start-up by invoking this method during your texture's network fetch for increased concurrency.
+     */
     compileEquirectangularShader(): void;
+
+    /**
+     * Frees the GPU-related resources allocated by this instance
+     * @remarks
+     * Call this method whenever this instance is no longer used in your app.
+     */
     dispose(): void;
 }

three/src/extras/ShapeUtils.d.ts

@@ -3,8 +3,26 @@ export interface Vec2 {
     y: number;
 }
 
+/**
+ * A class containing utility functions for shapes.
+ * @remarks Note that these are all linear functions so it is necessary to calculate separately for x, y (and z, w if present) components of a vector.
+ * @see {@link https://threejs.org/docs/index.html#api/en/extras/ShapeUtils | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/ShapeUtils.js | Source}
+ */
 export namespace ShapeUtils {
+    /**
+     * Calculate area of a ( 2D ) contour polygon.
+     */
     function area(contour: Vec2[]): number;
-    function triangulateShape(contour: Vec2[], holes: Vec2[][]): number[][];
+
+    /**
+     * Note that this is a linear function so it is necessary to calculate separately for x, y components of a polygon.
+     * @remarks Used internally by {@link THREE.Path | Path}, {@link THREE.ExtrudeGeometry | ExtrudeGeometry} and {@link THREE.ShapeGeometry | ShapeGeometry}.
+     */
     function isClockWise(pts: Vec2[]): boolean;
+
+    /**
+     * Used internally by {@link THREE.ExtrudeGeometry | ExtrudeGeometry} and {@link THREE.ShapeGeometry | ShapeGeometry} to calculate faces in shapes with holes.
+     */
+    function triangulateShape(contour: Vec2[], holes: Vec2[][]): number[][];
 }

three/src/extras/core/Curve.d.ts

@@ -1,84 +1,128 @@
 import { Vector } from './../../math/Vector2';
 import { Vector3 } from './../../math/Vector3';
 
-// Extras / Core /////////////////////////////////////////////////////////////////////
-
 /**
- * An extensible curve object which contains methods for interpolation
- * class Curve<T extends Vector>
+ * 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 class Curve<T extends Vector> {
+export abstract class Curve<T extends Vector> {
+    protected constructor();
+
     /**
-     * @default 'Curve'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `Curve`
      */
-    type: string;
+    readonly type: string | 'Curve';
 
     /**
-     * This value determines the amount of divisions when calculating the cumulative segment lengths of a curve via .getLengths.
-     * To ensure precision when using methods like .getSpacedPoints, it is recommended to increase .arcLengthDivisions if the curve is very large.
-     * @default 200
+     * 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 point t of the curve where t is between 0 and 1
-     * getPoint(t: number, optionalTarget?: T): T;
+     * 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?: T): T;
 
     /**
-     * Returns a vector for point at relative position in curve according to arc length
-     * getPointAt(u: number, optionalTarget?: T): T;
+     * 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?: T): T;
 
     /**
-     * Get sequence of points using getPoint( t )
-     * getPoints(divisions?: number): T[];
+     * 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): T[];
 
     /**
-     * Get sequence of equi-spaced points using getPointAt( u )
-     * getSpacedPoints(divisions?: number): T[];
+     * 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): T[];
 
     /**
-     * Get total curve arc length
+     * Get total {@link Curve} arc length.
      */
     getLength(): number;
 
     /**
-     * Get list of cumulative segment lengths
+     * Get list of cumulative segment lengths.
+     * @param divisions Expects a `Integer`
      */
     getLengths(divisions?: number): number[];
 
     /**
      * Update the cumlative 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 ( 0 .. 1 ), get a t to find p. This gives you points which are equi distance
+     * 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. If the subclassed curve do not implement its tangent derivation, 2 points a
-     * small delta apart will be used to find its gradient which seems to give a reasonable approximation
-     * getTangent(t: number, optionalTarget?: T): T;
+     * 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?: T): T;
 
     /**
-     * Returns tangent at equidistance point u on the curve
-     * getTangentAt(u: number, optionalTarget?: T): T;
+     * 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?: T): T;
 
     /**
-     * Generate Frenet frames of the curve
+     * 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,
@@ -89,13 +133,24 @@ export class Curve<T extends Vector> {
         binormals: Vector3[];
     };
 
+    /**
+     * Creates a clone of this instance.
+     */
     clone(): this;
+    /**
+     * Copies another {@link Curve} object to this instance.
+     * @param source
+     */
     copy(source: Curve<T>): this;
-    toJSON(): object;
-    fromJSON(json: object): this;
 
     /**
-     * @deprecated since r84.
+     * Returns a JSON object representation of this instance.
+     */
+    toJSON(): {};
+
+    /**
+     * Copies the data from the given JSON object to this instance.
+     * @param json
      */
-    static create(constructorFunc: () => void, getPointFunc: () => void): () => void;
+    fromJSON(json: {}): this;
 }

three/src/extras/core/CurvePath.d.ts

@@ -1,26 +1,68 @@
 import { Curve } from './Curve';
 import { Vector } from './../../math/Vector2';
 
+/**
+ * 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<T extends Vector> extends Curve<T> {
+    /**
+     * The constructor take no parameters.
+     */
     constructor();
 
     /**
-     * @default 'CurvePath'
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `CurvePath`
      */
-    type: string;
+    override readonly type: string | 'CurvePath';
 
     /**
-     * @default []
+     * The array of {@link Curve | Curves}.
+     * @defaultValue `[]`
      */
     curves: Array<Curve<T>>;
 
     /**
-     * @default false
+     * 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<T>): void;
+    /**
+     * Adds a {@link LineCurve | lineCurve} to close the path.
+     */
     closePath(): void;
+
     getPoint(t: number, optionalTarget?: T): T;
+
+    /**
+     * 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): T[];
+
+    /**
+     * 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): T[];
 }