@types/three 0.155.1 → 0.157.0

three/examples/jsm/libs/tween.module.d.ts

@@ -1,2 +1,219 @@
-export * from '@tweenjs/tween.js';
-export { default } from '@tweenjs/tween.js';
+type EasingFunction = (amount: number) => number;
+interface EasingFunctionGroup {
+    In: EasingFunction;
+    Out: EasingFunction;
+    InOut: EasingFunction;
+}
+/**
+ * The Ease class provides a collection of easing functions for use with tween.js.
+ */
+declare const Easing: Readonly<{
+    Linear: Readonly<
+        EasingFunctionGroup & {
+            None: EasingFunction;
+        }
+    >;
+    Quadratic: Readonly<EasingFunctionGroup>;
+    Cubic: Readonly<EasingFunctionGroup>;
+    Quartic: Readonly<EasingFunctionGroup>;
+    Quintic: Readonly<EasingFunctionGroup>;
+    Sinusoidal: Readonly<EasingFunctionGroup>;
+    Exponential: Readonly<EasingFunctionGroup>;
+    Circular: Readonly<EasingFunctionGroup>;
+    Elastic: Readonly<EasingFunctionGroup>;
+    Back: Readonly<EasingFunctionGroup>;
+    Bounce: Readonly<EasingFunctionGroup>;
+    generatePow(power?: number): EasingFunctionGroup;
+}>;
+
+type InterpolationFunction = (v: number[], k: number) => number;
+declare const Interpolation: {
+    Linear: (v: number[], k: number) => number;
+    Bezier: (v: number[], k: number) => number;
+    CatmullRom: (v: number[], k: number) => number;
+    Utils: {
+        Linear: (p0: number, p1: number, t: number) => number;
+        Bernstein: (n: number, i: number) => number;
+        Factorial: (n: number) => number;
+        CatmullRom: (p0: number, p1: number, p2: number, p3: number, t: number) => number;
+    };
+};
+
+/**
+ * Controlling groups of tweens
+ *
+ * Using the TWEEN singleton to manage your tweens can cause issues in large apps with many components.
+ * In these cases, you may want to create your own smaller groups of tween
+ */
+declare class Group {
+    private _tweens;
+    private _tweensAddedDuringUpdate;
+    getAll(): Array<Tween<UnknownProps>>;
+    removeAll(): void;
+    add(tween: Tween<UnknownProps>): void;
+    remove(tween: Tween<UnknownProps>): void;
+    update(time?: number, preserve?: boolean): boolean;
+}
+
+/**
+ * Tween.js - Licensed under the MIT license
+ * https://github.com/tweenjs/tween.js
+ * ----------------------------------------------
+ *
+ * See https://github.com/tweenjs/tween.js/graphs/contributors for the full list of contributors.
+ * Thank you all, you're awesome!
+ */
+
+declare class Tween<T extends UnknownProps> {
+    private _object;
+    private _group;
+    private _isPaused;
+    private _pauseStart;
+    private _valuesStart;
+    private _valuesEnd;
+    private _valuesStartRepeat;
+    private _duration;
+    private _isDynamic;
+    private _initialRepeat;
+    private _repeat;
+    private _repeatDelayTime?;
+    private _yoyo;
+    private _isPlaying;
+    private _reversed;
+    private _delayTime;
+    private _startTime;
+    private _easingFunction;
+    private _interpolationFunction;
+    private _chainedTweens;
+    private _onStartCallback?;
+    private _onStartCallbackFired;
+    private _onEveryStartCallback?;
+    private _onEveryStartCallbackFired;
+    private _onUpdateCallback?;
+    private _onRepeatCallback?;
+    private _onCompleteCallback?;
+    private _onStopCallback?;
+    private _id;
+    private _isChainStopped;
+    private _propertiesAreSetUp;
+    constructor(_object: T, _group?: Group | false);
+    getId(): number;
+    isPlaying(): boolean;
+    isPaused(): boolean;
+    to(target: UnknownProps, duration?: number): this;
+    duration(duration?: number): this;
+    dynamic(dynamic?: boolean): this;
+    start(time?: number, overrideStartingValues?: boolean): this;
+    startFromCurrentValues(time?: number): this;
+    private _setupProperties;
+    stop(): this;
+    end(): this;
+    pause(time?: number): this;
+    resume(time?: number): this;
+    stopChainedTweens(): this;
+    group(group?: Group): this;
+    delay(amount?: number): this;
+    repeat(times?: number): this;
+    repeatDelay(amount?: number): this;
+    yoyo(yoyo?: boolean): this;
+    easing(easingFunction?: EasingFunction): this;
+    interpolation(interpolationFunction?: InterpolationFunction): this;
+    chain(...tweens: Array<Tween<any>>): this;
+    onStart(callback?: (object: T) => void): this;
+    onEveryStart(callback?: (object: T) => void): this;
+    onUpdate(callback?: (object: T, elapsed: number) => void): this;
+    onRepeat(callback?: (object: T) => void): this;
+    onComplete(callback?: (object: T) => void): this;
+    onStop(callback?: (object: T) => void): this;
+    private _goToEnd;
+    /**
+     * @returns true if the tween is still playing after the update, false
+     * otherwise (calling update on a paused tween still returns true because
+     * it is still playing, just paused).
+     */
+    update(time?: number, autoStart?: boolean): boolean;
+    private _updateProperties;
+    private _handleRelativeValue;
+    private _swapEndStartRepeatValues;
+}
+type UnknownProps = Record<string, any>;
+
+declare function now(): number;
+
+/**
+ * Utils
+ */
+// tslint:disable-next-line:no-unnecessary-class
+declare class Sequence {
+    private static _nextId;
+    static nextId(): number;
+}
+
+declare const VERSION = '21.0.0';
+
+declare const nextId: typeof Sequence.nextId;
+declare function getAll(): Array<Tween<UnknownProps>>;
+declare function removeAll(): void;
+declare function add(tween: Tween<UnknownProps>): void;
+declare function remove(tween: Tween<UnknownProps>): void;
+declare function update(time?: number, preserve?: boolean): boolean;
+
+declare const exports: {
+    Easing: Readonly<{
+        Linear: Readonly<
+            EasingFunctionGroup & {
+                None: EasingFunction;
+            }
+        >;
+        Quadratic: Readonly<EasingFunctionGroup>;
+        Cubic: Readonly<EasingFunctionGroup>;
+        Quartic: Readonly<EasingFunctionGroup>;
+        Quintic: Readonly<EasingFunctionGroup>;
+        Sinusoidal: Readonly<EasingFunctionGroup>;
+        Exponential: Readonly<EasingFunctionGroup>;
+        Circular: Readonly<EasingFunctionGroup>;
+        Elastic: Readonly<EasingFunctionGroup>;
+        Back: Readonly<EasingFunctionGroup>;
+        Bounce: Readonly<EasingFunctionGroup>;
+        generatePow(power?: number): EasingFunctionGroup;
+    }>;
+    Group: typeof Group;
+    Interpolation: {
+        Linear: (v: number[], k: number) => number;
+        Bezier: (v: number[], k: number) => number;
+        CatmullRom: (v: number[], k: number) => number;
+        Utils: {
+            Linear: (p0: number, p1: number, t: number) => number;
+            Bernstein: (n: number, i: number) => number;
+            Factorial: (n: number) => number;
+            CatmullRom: (p0: number, p1: number, p2: number, p3: number, t: number) => number;
+        };
+    };
+    now: () => number;
+    Sequence: typeof Sequence;
+    nextId: typeof Sequence.nextId;
+    Tween: typeof Tween;
+    VERSION: string;
+    getAll: () => Array<Tween<UnknownProps>>;
+    removeAll: () => void;
+    add: (tween: Tween<UnknownProps>) => void;
+    remove: (tween: Tween<UnknownProps>) => void;
+    update: (time?: number, preserve?: boolean) => boolean;
+};
+
+export {
+    Easing,
+    Group,
+    Interpolation,
+    Sequence,
+    Tween,
+    VERSION,
+    add,
+    exports as default,
+    getAll,
+    nextId,
+    now,
+    remove,
+    removeAll,
+    update,
+};

three/examples/jsm/loaders/3DMLoader.d.ts

@@ -1,15 +1,8 @@
 import { Loader, LoadingManager, Object3D } from '../../../src/Three.js';
 
-export class Rhino3dmLoader extends Loader {
+export class Rhino3dmLoader extends Loader<Object3D> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (object: Object3D) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Object3D>;
     parse(data: ArrayBufferLike, onLoad: (object: Object3D) => void, onError?: (event: ErrorEvent) => void): void;
     setLibraryPath(path: string): Rhino3dmLoader;
     setWorkerLimit(workerLimit: number): Rhino3dmLoader;

three/examples/jsm/loaders/3MFLoader.d.ts

@@ -1,16 +1,9 @@
 import { Loader, LoadingManager, Group } from '../../../src/Three.js';
 
-export class ThreeMFLoader extends Loader {
+export class ThreeMFLoader extends Loader<Group> {
     constructor(manager?: LoadingManager);
     availableExtensions: object[];
 
-    load(
-        url: string,
-        onLoad: (object: Group) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>;
     parse(data: ArrayBuffer): Group;
     addExtension(extension: object): void;
 }

three/examples/jsm/loaders/AMFLoader.d.ts

@@ -1,14 +1,7 @@
 import { Loader, LoadingManager, Group } from '../../../src/Three.js';
 
-export class AMFLoader extends Loader {
+export class AMFLoader extends Loader<Group> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (object: Group) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>;
     parse(data: ArrayBuffer): Group;
 }

three/examples/jsm/loaders/BVHLoader.d.ts

@@ -5,17 +5,10 @@ export interface BVH {
     skeleton: Skeleton;
 }
 
-export class BVHLoader extends Loader {
+export class BVHLoader extends Loader<BVH> {
     constructor(manager?: LoadingManager);
     animateBonePositions: boolean;
     animateBoneRotations: boolean;
 
-    load(
-        url: string,
-        onLoad: (bvh: BVH) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BVH>;
     parse(text: string): BVH;
 }

three/examples/jsm/loaders/ColladaLoader.d.ts

@@ -6,15 +6,8 @@ export interface Collada {
     scene: Scene;
 }
 
-export class ColladaLoader extends Loader {
+export class ColladaLoader extends Loader<Collada> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (collada: Collada) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Collada>;
     parse(text: string, path: string): Collada;
 }

three/examples/jsm/loaders/DRACOLoader.d.ts

@@ -1,18 +1,19 @@
 import { Loader, LoadingManager, BufferGeometry } from '../../../src/Three.js';
 
-export class DRACOLoader extends Loader {
+export class DRACOLoader extends Loader<BufferGeometry> {
     constructor(manager?: LoadingManager);
 
+    setDecoderPath(path: string): DRACOLoader;
+    setDecoderConfig(config: object): DRACOLoader;
+    setWorkerLimit(workerLimit: number): DRACOLoader;
+
     load(
         url: string,
-        onLoad: (geometry: BufferGeometry) => void,
+        onLoad?: (data: BufferGeometry) => void,
         onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
+        onError?: (err: unknown) => void,
     ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry>;
-    setDecoderPath(path: string): DRACOLoader;
-    setDecoderConfig(config: object): DRACOLoader;
-    setWorkerLimit(workerLimit: number): DRACOLoader;
+
     preload(): DRACOLoader;
     dispose(): DRACOLoader;
 }

three/examples/jsm/loaders/FBXLoader.d.ts

@@ -1,14 +1,7 @@
 import { Group, Loader, LoadingManager } from '../../../src/Three.js';
 
-export class FBXLoader extends Loader {
+export class FBXLoader extends Loader<Group> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (object: Group) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>;
     parse(FBXBuffer: ArrayBuffer | string, path: string): Group;
 }

three/examples/jsm/loaders/FontLoader.d.ts

@@ -1,15 +1,15 @@
 import { Shape, Loader, LoadingManager } from '../../../src/Three.js';
 
-export class FontLoader extends Loader {
+export class FontLoader extends Loader<Font> {
     constructor(manager?: LoadingManager);
 
     load(
         url: string,
-        onLoad?: (responseFont: Font) => void,
+        onLoad?: (data: Font) => void,
         onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
+        onError?: (err: unknown) => void,
     ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Font>;
+
     parse(json: any): Font;
 }
 

three/examples/jsm/loaders/GCodeLoader.d.ts

@@ -1,15 +1,8 @@
 import { Group, Loader, LoadingManager } from '../../../src/Three.js';
 
-export class GCodeLoader extends Loader {
+export class GCodeLoader extends Loader<Group> {
     constructor(manager?: LoadingManager);
     splitLayer: boolean;
 
-    load(
-        url: string,
-        onLoad: (object: Group) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>;
     parse(data: string): Group;
 }

three/examples/jsm/loaders/GLTFLoader.d.ts

@@ -39,18 +39,10 @@ export interface GLTF {
     userData: any;
 }
 
-export class GLTFLoader extends Loader {
+export class GLTFLoader extends Loader<GLTF> {
     constructor(manager?: LoadingManager);
     dracoLoader: DRACOLoader | null;
 
-    load(
-        url: string,
-        onLoad: (gltf: GLTF) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<GLTF>;
-
     setDRACOLoader(dracoLoader: DRACOLoader): GLTFLoader;
 
     register(callback: (parser: GLTFParser) => GLTFLoaderPlugin): GLTFLoader;

three/examples/jsm/loaders/HDRCubeTextureLoader.d.ts

@@ -2,17 +2,17 @@ import { CubeTexture, Loader, LoadingManager, TextureDataType } from '../../../s
 
 import { RGBELoader } from './RGBELoader.js';
 
-export class HDRCubeTextureLoader extends Loader {
+export class HDRCubeTextureLoader extends Loader<CubeTexture, readonly string[]> {
     constructor(manager?: LoadingManager);
     hdrLoader: RGBELoader;
     type: TextureDataType;
 
     load(
-        urls: string[],
-        onLoad: (texture: CubeTexture) => void,
+        url: readonly string[],
+        onLoad?: (data: CubeTexture) => void,
         onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
+        onError?: (err: unknown) => void,
     ): CubeTexture;
-    loadAsync(urls: string[], onProgress?: (event: ProgressEvent) => void): Promise<CubeTexture>;
+
     setDataType(type: TextureDataType): this;
 }

three/examples/jsm/loaders/KMZLoader.d.ts

@@ -2,15 +2,8 @@ import { Loader, LoadingManager } from '../../../src/Three.js';
 
 import { Collada } from './ColladaLoader.js';
 
-export class KMZLoader extends Loader {
+export class KMZLoader extends Loader<Collada> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (kmz: Collada) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Collada>;
     parse(data: ArrayBuffer): Collada;
 }

three/examples/jsm/loaders/LDrawLoader.d.ts

@@ -1,6 +1,6 @@
 import { Loader, LoadingManager, Group, Material } from '../../../src/Three.js';
 
-export class LDrawLoader extends Loader {
+export class LDrawLoader extends Loader<Group> {
     materials: Material[];
     materialsLibrary: Record<string, Material>;
     fileMap: Record<string, string>;
@@ -8,13 +8,6 @@ export class LDrawLoader extends Loader {
 
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (data: Group) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>;
     preloadMaterials(url: string): Promise<void>;
     setFileMap(fileMap: Record<string, string>): void;
     setMaterials(materials: Material[]): void;

three/examples/jsm/loaders/LUT3dlLoader.d.ts

@@ -6,15 +6,8 @@ export interface LUT3dlResult {
     texture3D: Data3DTexture;
 }
 
-export class LUT3dlLoader extends Loader {
+export class LUT3dlLoader extends Loader<LUT3dlResult> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (result: LUT3dlResult) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: Error) => void,
-    ): any;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<LUT3dlResult>;
     parse(data: string): LUT3dlResult;
 }

three/examples/jsm/loaders/LUTCubeLoader.d.ts

@@ -9,15 +9,8 @@ export interface LUTCubeResult {
     texture3D: Data3DTexture;
 }
 
-export class LUTCubeLoader extends Loader {
+export class LUTCubeLoader extends Loader<LUTCubeResult> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (result: LUTCubeResult) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: Error) => void,
-    ): any;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<LUTCubeResult>;
     parse(data: string): LUTCubeResult;
 }

three/examples/jsm/loaders/LWOLoader.d.ts

@@ -12,15 +12,8 @@ export interface LWOLoaderParameters {
     resourcePath?: string;
 }
 
-export class LWOLoader extends Loader {
+export class LWOLoader extends Loader<LWO> {
     constructor(manager?: LoadingManager, parameters?: LWOLoaderParameters);
 
-    load(
-        url: string,
-        onLoad: (lwo: LWO) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<LWO>;
     parse(data: ArrayBuffer, path: string, modelName: string): LWO;
 }

three/examples/jsm/loaders/LottieLoader.d.ts

@@ -1,15 +1,14 @@
 import { CanvasTexture, Loader, LoadingManager } from '../../../src/Three.js';
 
-export class LottieLoader extends Loader {
+export class LottieLoader extends Loader<CanvasTexture> {
     constructor(manager?: LoadingManager);
 
     load(
         url: string,
-        onLoad: (texture: CanvasTexture) => void,
+        onLoad?: (data: CanvasTexture) => void,
         onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<CanvasTexture>;
+        onError?: (err: unknown) => void,
+    ): CanvasTexture;
 
     setQuality(value: number): void;
 }

three/examples/jsm/loaders/MD2Loader.d.ts

@@ -1,14 +1,7 @@
 import { BufferGeometry, Loader, LoadingManager } from '../../../src/Three.js';
 
-export class MD2Loader extends Loader {
+export class MD2Loader extends Loader<BufferGeometry> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (geometry: BufferGeometry) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry>;
     parse(data: ArrayBuffer): BufferGeometry;
 }

three/examples/jsm/loaders/MDDLoader.d.ts

@@ -5,15 +5,8 @@ export interface MDD {
     clip: AnimationClip;
 }
 
-export class MDDLoader extends Loader {
+export class MDDLoader extends Loader<MDD> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (result: MDD) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<MDD>;
     parse(data: ArrayBuffer): MDD;
 }

three/examples/jsm/loaders/MMDLoader.d.ts

@@ -5,7 +5,7 @@ export interface MMDLoaderAnimationObject {
     mesh: SkinnedMesh;
 }
 
-export class MMDLoader extends Loader {
+export class MMDLoader extends Loader<SkinnedMesh> {
     constructor(manager?: LoadingManager);
     animationBuilder: object;
     animationPath: string;
@@ -13,13 +13,6 @@ export class MMDLoader extends Loader {
     meshBuilder: object;
     parser: object | null;
 
-    load(
-        url: string,
-        onLoad: (mesh: SkinnedMesh) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<SkinnedMesh>;
     loadAnimation(
         url: string,
         object: SkinnedMesh | Camera,