@types/three 0.157.0 → 0.157.1

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

@@ -1,219 +0,0 @@
-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/lights/RectAreaLightUniformsLib.d.ts

@@ -1,3 +0,0 @@
-export namespace RectAreaLightUniformsLib {
-    function init(): void;
-}

three/examples/jsm/lines/Line2.d.ts

@@ -1,11 +0,0 @@
-import { LineGeometry } from './LineGeometry.js';
-import { LineSegments2 } from './LineSegments2.js';
-import { LineMaterial } from './LineMaterial.js';
-
-export class Line2 extends LineSegments2 {
-    geometry: LineGeometry;
-    material: LineMaterial;
-
-    constructor(geometry?: LineGeometry, material?: LineMaterial);
-    readonly isLine2: true;
-}

three/examples/jsm/lines/LineGeometry.d.ts

@@ -1,10 +0,0 @@
-import { Line } from '../../../src/Three.js';
-
-import { LineSegmentsGeometry } from './LineSegmentsGeometry.js';
-
-export class LineGeometry extends LineSegmentsGeometry {
-    constructor();
-    readonly isLineGeometry: true;
-
-    fromLine(line: Line): this;
-}

three/examples/jsm/lines/LineMaterial.d.ts

@@ -1,31 +0,0 @@
-import { Color, MaterialParameters, ShaderMaterial, Vector2 } from '../../../src/Three.js';
-
-export interface LineMaterialParameters extends MaterialParameters {
-    alphaToCoverage?: boolean | undefined;
-    color?: number | undefined;
-    dashed?: boolean | undefined;
-    dashScale?: number | undefined;
-    dashSize?: number | undefined;
-    dashOffset?: number | undefined;
-    gapSize?: number | undefined;
-    linewidth?: number | undefined;
-    resolution?: Vector2 | undefined;
-    wireframe?: boolean | undefined;
-    worldUnits?: boolean | undefined;
-}
-
-export class LineMaterial extends ShaderMaterial {
-    constructor(parameters?: LineMaterialParameters);
-    color: Color;
-    dashed: boolean;
-    dashScale: number;
-    dashSize: number;
-    dashOffset: number;
-    gapSize: number;
-    opacity: number;
-    readonly isLineMaterial: true;
-    linewidth: number;
-    resolution: Vector2;
-    alphaToCoverage: boolean;
-    worldUnits: boolean;
-}

three/examples/jsm/lines/LineSegments2.d.ts

@@ -1,14 +0,0 @@
-import { Mesh } from '../../../src/Three.js';
-
-import { LineMaterial } from './LineMaterial.js';
-import { LineSegmentsGeometry } from './LineSegmentsGeometry.js';
-
-export class LineSegments2 extends Mesh {
-    geometry: LineSegmentsGeometry;
-    material: LineMaterial;
-
-    constructor(geometry?: LineSegmentsGeometry, material?: LineMaterial);
-    readonly isLineSegments2: true;
-
-    computeLineDistances(): this;
-}

three/examples/jsm/lines/LineSegmentsGeometry.d.ts

@@ -1,23 +0,0 @@
-import {
-    EdgesGeometry,
-    InstancedBufferGeometry,
-    LineSegments,
-    Matrix4,
-    Mesh,
-    WireframeGeometry,
-} from '../../../src/Three.js';
-
-export class LineSegmentsGeometry extends InstancedBufferGeometry {
-    constructor();
-    readonly isLineSegmentsGeometry: true;
-
-    applyMatrix4(matrix: Matrix4): this;
-    computeBoundingBox(): void;
-    computeBoundingSphere(): void;
-    fromEdgesGeometry(geometry: EdgesGeometry): this;
-    fromLineSegments(lineSegments: LineSegments): this;
-    fromMesh(mesh: Mesh): this;
-    fromWireframeGeometry(geometry: WireframeGeometry): this;
-    setColors(array: number[] | Float32Array): this;
-    setPositions(array: number[] | Float32Array): this;
-}

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

@@ -1,16 +0,0 @@
-import { LoadingManager, CompressedTextureLoader, PixelFormat, CompressedPixelFormat } from '../../../src/Three.js';
-
-export interface DDS {
-    mipmaps: object[];
-    width: number;
-    height: number;
-    format: PixelFormat | CompressedPixelFormat;
-    mipmapCount: number;
-    isCubemap: boolean;
-}
-
-export class DDSLoader extends CompressedTextureLoader {
-    constructor(manager?: LoadingManager);
-
-    parse(buffer: ArrayBuffer, loadMipmaps: boolean): DDS;
-}

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

@@ -1,19 +0,0 @@
-import { Loader, LoadingManager, BufferGeometry } from '../../../src/Three.js';
-
-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?: (data: BufferGeometry) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (err: unknown) => void,
-    ): void;
-
-    preload(): DRACOLoader;
-    dispose(): DRACOLoader;
-}

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

@@ -1,27 +0,0 @@
-import { Shape, Loader, LoadingManager } from '../../../src/Three.js';
-
-export class FontLoader extends Loader<Font> {
-    constructor(manager?: LoadingManager);
-
-    load(
-        url: string,
-        onLoad?: (data: Font) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (err: unknown) => void,
-    ): void;
-
-    parse(json: any): Font;
-}
-
-export class Font {
-    constructor(jsondata: any);
-
-    /**
-     * @default 'Font'
-     */
-    type: string;
-
-    data: string;
-
-    generateShapes(text: string, size: number): Shape[];
-}

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

@@ -1,147 +0,0 @@
-import {
-    AnimationClip,
-    BufferAttribute,
-    BufferGeometry,
-    Camera,
-    Group,
-    InterleavedBufferAttribute,
-    Loader,
-    LoadingManager,
-    Mesh,
-    MeshStandardMaterial,
-    Object3D,
-    Material,
-    SkinnedMesh,
-    Texture,
-    TextureLoader,
-    FileLoader,
-    ImageBitmapLoader,
-    Skeleton,
-} from '../../../src/Three.js';
-
-import { DRACOLoader } from './DRACOLoader.js';
-import { KTX2Loader } from './KTX2Loader.js';
-
-export interface GLTF {
-    animations: AnimationClip[];
-    scene: Group;
-    scenes: Group[];
-    cameras: Camera[];
-    asset: {
-        copyright?: string | undefined;
-        generator?: string | undefined;
-        version?: string | undefined;
-        minVersion?: string | undefined;
-        extensions?: any;
-        extras?: any;
-    };
-    parser: GLTFParser;
-    userData: any;
-}
-
-export class GLTFLoader extends Loader<GLTF> {
-    constructor(manager?: LoadingManager);
-    dracoLoader: DRACOLoader | null;
-
-    setDRACOLoader(dracoLoader: DRACOLoader): GLTFLoader;
-
-    register(callback: (parser: GLTFParser) => GLTFLoaderPlugin): GLTFLoader;
-    unregister(callback: (parser: GLTFParser) => GLTFLoaderPlugin): GLTFLoader;
-
-    setKTX2Loader(ktx2Loader: KTX2Loader): GLTFLoader;
-    setMeshoptDecoder(meshoptDecoder: /* MeshoptDecoder */ any): GLTFLoader;
-
-    parse(
-        data: ArrayBuffer | string,
-        path: string,
-        onLoad: (gltf: GLTF) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-
-    parseAsync(data: ArrayBuffer | string, path: string): Promise<GLTF>;
-}
-
-export type GLTFReferenceType = 'materials' | 'nodes' | 'textures' | 'meshes';
-
-export interface GLTFReference {
-    materials?: number;
-    nodes?: number;
-    textures?: number;
-    meshes?: number;
-}
-
-export class GLTFParser {
-    json: any;
-
-    options: {
-        path: string;
-        manager: LoadingManager;
-        ktx2Loader: KTX2Loader;
-        meshoptDecoder: /* MeshoptDecoder */ any;
-        crossOrigin: string;
-        requestHeader: { [header: string]: string };
-    };
-
-    fileLoader: FileLoader;
-    textureLoader: TextureLoader | ImageBitmapLoader;
-    plugins: { [name: string]: GLTFLoaderPlugin };
-    extensions: { [name: string]: any };
-    associations: Map<Object3D | Material | Texture, GLTFReference>;
-
-    setExtensions(extensions: { [name: string]: any }): void;
-    setPlugins(plugins: { [name: string]: GLTFLoaderPlugin }): void;
-
-    parse(onLoad: (gltf: GLTF) => void, onError?: (event: ErrorEvent) => void): void;
-
-    getDependency: (type: string, index: number) => Promise<any>;
-    getDependencies: (type: string) => Promise<any[]>;
-    loadBuffer: (bufferIndex: number) => Promise<ArrayBuffer>;
-    loadBufferView: (bufferViewIndex: number) => Promise<ArrayBuffer>;
-    loadAccessor: (accessorIndex: number) => Promise<BufferAttribute | InterleavedBufferAttribute>;
-    loadTexture: (textureIndex: number) => Promise<Texture>;
-    loadTextureImage: (textureIndex: number, sourceIndex: number, loader: Loader) => Promise<Texture>;
-    loadImageSource: (sourceIndex: number, loader: Loader) => Promise<Texture>;
-    assignTexture: (
-        materialParams: { [key: string]: any },
-        mapName: string,
-        mapDef: {
-            index: number;
-            texCoord?: number | undefined;
-            extensions?: any;
-        },
-    ) => Promise<void>;
-    assignFinalMaterial: (object: Mesh) => void;
-    getMaterialType: () => typeof MeshStandardMaterial;
-    loadMaterial: (materialIndex: number) => Promise<Material>;
-    createUniqueName: (originalName: string) => string;
-    createNodeMesh: (nodeIndex: number) => Promise<Group | Mesh | SkinnedMesh>;
-    loadGeometries: (
-        /**
-         * GLTF.Primitive[]
-         * See: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/schema/mesh.primitive.schema.json
-         */
-        primitives: Array<{ [key: string]: any }>,
-    ) => Promise<BufferGeometry[]>;
-    loadMesh: (meshIndex: number) => Promise<Group | Mesh | SkinnedMesh>;
-    loadCamera: (cameraIndex: number) => Promise<Camera>;
-    loadSkin: (skinIndex: number) => Promise<Skeleton>;
-    loadAnimation: (animationIndex: number) => Promise<AnimationClip>;
-    loadNode: (nodeIndex: number) => Promise<Object3D>;
-    loadScene: () => Promise<Group>;
-}
-
-export interface GLTFLoaderPlugin {
-    beforeRoot?: (() => Promise<void> | null) | undefined;
-    afterRoot?: ((result: GLTF) => Promise<void> | null) | undefined;
-    loadNode?: ((nodeIndex: number) => Promise<Object3D> | null) | undefined;
-    loadMesh?: ((meshIndex: number) => Promise<Group | Mesh | SkinnedMesh> | null) | undefined;
-    loadBufferView?: ((bufferViewIndex: number) => Promise<ArrayBuffer> | null) | undefined;
-    loadMaterial?: ((materialIndex: number) => Promise<Material> | null) | undefined;
-    loadTexture?: ((textureIndex: number) => Promise<Texture> | null) | undefined;
-    getMaterialType?: ((materialIndex: number) => typeof Material | null) | undefined;
-    extendMaterialParams?:
-        | ((materialIndex: number, materialParams: { [key: string]: any }) => Promise<any> | null)
-        | undefined;
-    createNodeMesh?: ((nodeIndex: number) => Promise<Group | Mesh | SkinnedMesh> | null) | undefined;
-    createNodeAttachment?: ((nodeIndex: number) => Promise<Object3D> | null) | undefined;
-}

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

@@ -1,18 +0,0 @@
-import { CubeTexture, Loader, LoadingManager, TextureDataType } from '../../../src/Three.js';
-
-import { RGBELoader } from './RGBELoader.js';
-
-export class HDRCubeTextureLoader extends Loader<CubeTexture, readonly string[]> {
-    constructor(manager?: LoadingManager);
-    hdrLoader: RGBELoader;
-    type: TextureDataType;
-
-    load(
-        url: readonly string[],
-        onLoad?: (data: CubeTexture) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (err: unknown) => void,
-    ): CubeTexture;
-
-    setDataType(type: TextureDataType): this;
-}

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

@@ -1,16 +0,0 @@
-import { LoadingManager, CompressedTextureLoader, CompressedTexture, WebGLRenderer } from '../../../src/Three.js';
-
-export class KTX2Loader extends CompressedTextureLoader {
-    constructor(manager?: LoadingManager);
-
-    setTranscoderPath(path: string): KTX2Loader;
-    setWorkerLimit(limit: number): KTX2Loader;
-    detectSupport(renderer: WebGLRenderer): KTX2Loader;
-    dispose(): KTX2Loader;
-
-    parse(
-        buffer: ArrayBuffer,
-        onLoad: (texture: CompressedTexture) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): KTX2Loader;
-}

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

@@ -1,19 +0,0 @@
-import { Loader, LoadingManager, Group, Material } from '../../../src/Three.js';
-
-export class LDrawLoader extends Loader<Group> {
-    materials: Material[];
-    materialsLibrary: Record<string, Material>;
-    fileMap: Record<string, string>;
-    smoothNormals: boolean;
-
-    constructor(manager?: LoadingManager);
-
-    preloadMaterials(url: string): Promise<void>;
-    setFileMap(fileMap: Record<string, string>): void;
-    setMaterials(materials: Material[]): void;
-
-    parse(text: string, path: string, onLoad: (data: Group) => void): void;
-
-    addMaterial(material: Material): void;
-    getMaterial(colourCode: string): Material | null;
-}

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

@@ -1,56 +0,0 @@
-import { Camera, AnimationClip, FileLoader, Loader, LoadingManager, SkinnedMesh } from '../../../src/Three.js';
-
-export interface MMDLoaderAnimationObject {
-    animation: AnimationClip;
-    mesh: SkinnedMesh;
-}
-
-export class MMDLoader extends Loader<SkinnedMesh> {
-    constructor(manager?: LoadingManager);
-    animationBuilder: object;
-    animationPath: string;
-    loader: FileLoader;
-    meshBuilder: object;
-    parser: object | null;
-
-    loadAnimation(
-        url: string,
-        object: SkinnedMesh | Camera,
-        onLoad: (object: SkinnedMesh | AnimationClip) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadPMD(
-        url: string,
-        onLoad: (object: object) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadPMX(
-        url: string,
-        onLoad: (object: object) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadVMD(
-        url: string,
-        onLoad: (object: object) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadVPD(
-        url: string,
-        isUnicode: boolean,
-        onLoad: (object: object) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadWithAnimation(
-        url: string,
-        vmdUrl: string | string[],
-        onLoad: (object: MMDLoaderAnimationObject) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    setAnimationPath(animationPath: string): this;
-}