@needle-tools/three 0.169.12 → 0.169.14

package/types/src/lights/PointLight.d.ts

@@ -0,0 +1,102 @@
+import { ColorRepresentation } from "../math/Color.js";
+import { Light } from "./Light.js";
+import { PointLightShadow } from "./PointLightShadow.js";
+
+/**
+ * A light that gets emitted from a single point in all directions
+ * @remarks
+ * A common use case for this is to replicate the light emitted from a bare lightbulb.
+ * @example
+ * ```typescript
+ * const light = new THREE.PointLight(0xff0000, 1, 100);
+ * light.position.set(50, 50, 50);
+ * scene.add(light);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_lights_pointlights | lights / pointlights }
+ * @see Example: {@link https://threejs.org/examples/#webgl_effects_anaglyph | effects / anaglyph }
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_text | geometry / text }
+ * @see Example: {@link https://threejs.org/examples/#webgl_lensflares | lensflares }
+ * @see {@link https://threejs.org/docs/index.html#api/en/lights/PointLight | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/PointLight.js | Source}
+ */
+export class PointLight extends Light<PointLightShadow> {
+    /**
+     * Creates a new PointLight.
+     * @param color Hexadecimal color of the light. Default is 0xffffff (white). Expects a `Integer`
+     * @param intensity Numeric value of the light's strength/intensity. Expects a `Float`. Default `1`
+     * @param distance Maximum range of the light. Default is 0 (no limit).
+     * @param decay The amount the light dims along the distance of the light. Expects a `Float`. Default `2`
+     */
+    constructor(color?: ColorRepresentation, intensity?: number, distance?: number, decay?: number);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link PointLight}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isPointLight: true;
+
+    /**
+     * @default 'PointLight'
+     */
+    type: string;
+
+    /**
+     * The light's intensity.
+     *
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — intensity is the luminous intensity of the light measured in candela (cd).
+     * @remarks Changing the intensity will also change the light's power.
+     * @remarks Expects a `Float`
+     * @defaultValue `1`
+     */
+    intensity: number;
+
+    /**
+     * When **Default mode** — When distance is zero, light does not attenuate. When distance is non-zero,
+     * light will attenuate linearly from maximum intensity at the light's position down to zero at this distance from the light.
+     *
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — When distance is zero,
+     * light will attenuate according to inverse-square law to infinite distance.
+     * When distance is non-zero, light will attenuate according to inverse-square law until near the distance cutoff,
+     * where it will then attenuate quickly and smoothly to 0. Inherently, cutoffs are not physically correct.
+     *
+     * @defaultValue `0.0`
+     * @remarks Expects a `Float`
+     */
+    distance: number;
+
+    /**
+     * If set to `true` light will cast dynamic shadows.
+     * **Warning**: This is expensive and requires tweaking to get shadows looking right.
+     * @see {@link THREE.PointLightShadow | PointLightShadow} for details.
+     * @defaultValue `false`
+     */
+    castShadow: boolean;
+
+    /**
+     * The amount the light dims along the distance of the light.
+     * In context of physically-correct rendering the default value should not be changed.
+     * @remarks Expects a `Float`
+     * @defaultValue `2`
+     */
+    decay: number;
+
+    /**
+     * A {@link THREE.PointLightShadow | PointLightShadow} used to calculate shadows for this light.
+     * The lightShadow's {@link LightShadow.camera | camera} is set to
+     * a {@link THREE.PerspectiveCamera | PerspectiveCamera} with {@link PerspectiveCamera.fov | fov} of 90,
+     * {@link PerspectiveCamera.aspect | aspect} of 1,
+     * {@link PerspectiveCamera.near | near} clipping plane at 0.5
+     * and {@link PerspectiveCamera.far | far} clipping plane at 500.
+     * @defaultValue new THREE.PointLightShadow()
+     */
+    shadow: PointLightShadow;
+
+    /**
+     * The light's power.
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — power is the luminous power of the light measured in lumens (lm).
+     * @remarks Changing the power will also change the light's intensity.
+     * @remarks Expects a `Float`
+     */
+    power: number;
+}

package/types/src/lights/PointLightShadow.d.ts

@@ -0,0 +1,22 @@
+import { PerspectiveCamera } from "../cameras/PerspectiveCamera.js";
+import { Light } from "./Light.js";
+import { LightShadow } from "./LightShadow.js";
+
+/**
+ * Shadow for {@link THREE.PointLight | PointLight}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/PointLightShadow.js | Source}
+ */
+export class PointLightShadow extends LightShadow<PerspectiveCamera> {
+    /**
+     * Read-only flag to check if a given object is of type {@link PointLightShadow}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isPointLightShadow = true;
+
+    /**
+     * Update the matrices for the camera and shadow, used internally by the renderer.
+     * @param light The light for which the shadow is being rendered.
+     */
+    override updateMatrices(light: Light, viewportIndex?: number): void;
+}

package/types/src/lights/RectAreaLight.d.ts

@@ -0,0 +1,82 @@
+import { ColorRepresentation } from "../math/Color.js";
+import { Light } from "./Light.js";
+
+/**
+ * {@link RectAreaLight} emits light uniformly across the face a rectangular plane
+ * @remarks
+ * This light type can be used to simulate light sources such as bright windows or strip lighting.
+ * Important Notes:
+ *  - There is no shadow support.
+ *  - Only {@link MeshStandardMaterial | MeshStandardMaterial} and {@link MeshPhysicalMaterial | MeshPhysicalMaterial} are supported.
+ *  - You have to include {@link https://threejs.org/examples/jsm/lights/RectAreaLightUniformsLib.js | RectAreaLightUniformsLib} into your scene and call `init()`.
+ * @example
+ * ```typescript
+ * const width = 10;
+ * const height = 10;
+ * const intensity = 1;
+ * const rectLight = new THREE.RectAreaLight(0xffffff, intensity, width, height);
+ * rectLight.position.set(5, 5, 0);
+ * rectLight.lookAt(0, 0, 0);
+ * scene.add(rectLight)
+ * const rectLightHelper = new RectAreaLightHelper(rectLight);
+ * rectLight.add(rectLightHelper);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_lights_rectarealight | WebGL / {@link RectAreaLight} }
+ * @see {@link https://threejs.org/docs/index.html#api/en/lights/RectAreaLight | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/RectAreaLight.js | Source}
+ */
+export class RectAreaLight extends Light<undefined> {
+    /**
+     * Creates a new {@link RectAreaLight}.
+     * @param color Hexadecimal color of the light. Default `0xffffff` _(white)_.
+     * @param intensity The light's intensity, or brightness. Expects a `Float`. Default `1`
+     * @param width Width of the light. Expects a `Float`. Default `10`
+     * @param height Height of the light. Expects a `Float`. Default `10`
+     */
+    constructor(color?: ColorRepresentation, intensity?: number, width?: number, height?: number);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link RectAreaLight}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isRectAreaLight: true;
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `RectAreaLight`
+     */
+    override readonly type: string | "RectAreaLight";
+
+    /**
+     * The width of the light.
+     * @remarks Expects a `Float`
+     * @defaultValue `10`
+     */
+    width: number;
+
+    /**
+     * The height of the light.
+     * @remarks Expects a `Float`
+     * @defaultValue `10`
+     */
+    height: number;
+
+    /**
+     * The light's intensity.
+     * @remarks Changing the intensity will also change the light's power.
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — intensity is the luminance (brightness) of the light measured in nits (cd/m^2).
+     * @remarks Expects a `Float`
+     * @defaultValue `1`
+     */
+    intensity: number;
+
+    /**
+     * The light's power.
+     * @remarks Changing the power will also change the light's intensity.
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — power is the luminous power of the light measured in lumens (lm).
+     * @remarks Expects a `Float`
+     */
+    power: number;
+}

package/types/src/lights/SpotLight.d.ts

@@ -0,0 +1,164 @@
+import { Object3D } from "../core/Object3D.js";
+import { ColorRepresentation } from "../math/Color.js";
+import { Vector3 } from "../math/Vector3.js";
+import { Texture } from "../textures/Texture.js";
+import { Light } from "./Light.js";
+import { SpotLightShadow } from "./SpotLightShadow.js";
+
+/**
+ * This light gets emitted from a single point in one direction, along a cone that increases in size the further from the light it gets.
+ * @example
+ * ```typescript
+ * // white {@link SpotLight} shining from the side, modulated by a texture, casting a shadow
+ * const {@link SpotLight} = new THREE.SpotLight(0xffffff);
+ * spotLight.position.set(100, 1000, 100);
+ * spotLight.map = new THREE.TextureLoader().load(url);
+ * spotLight.castShadow = true;
+ * spotLight.shadow.mapSize.width = 1024;
+ * spotLight.shadow.mapSize.height = 1024;
+ * spotLight.shadow.camera.near = 500;
+ * spotLight.shadow.camera.far = 4000;
+ * spotLight.shadow.camera.fov = 30;
+ * scene.add(spotLight);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_lights_spotlight | lights / {@link SpotLight} }
+ * @see Example: {@link https://threejs.org/examples/#webgl_lights_spotlights | lights / spotlights }
+ * @see {@link https://threejs.org/docs/index.html#api/en/lights/SpotLight | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/SpotLight.js | Source}
+ */
+export class SpotLight extends Light<SpotLightShadow> {
+    /**
+     * Creates a new SpotLight.
+     * @param color Hexadecimal color of the light. Default `0xffffff` _(white)_.
+     * @param intensity Numeric value of the light's strength/intensity. Expects a `Float`. Default `1`.
+     * @param distance Maximum range of the light. Default is 0 (no limit). Expects a `Float`.
+     * @param angle Maximum angle of light dispersion from its direction whose upper bound is Math.PI/2.
+     * @param penumbra Percent of the {@link SpotLight} cone that is attenuated due to penumbra. Takes values between zero and 1. Expects a `Float`. Default `0`.
+     * @param decay The amount the light dims along the distance of the light. Expects a `Float`. Default `2`.
+     */
+    constructor(
+        color?: ColorRepresentation,
+        intensity?: number,
+        distance?: number,
+        angle?: number,
+        penumbra?: number,
+        decay?: number,
+    );
+
+    /**
+     * Read-only flag to check if a given object is of type {@link SpotLight}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isSpotLight: true;
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `SpotLight`
+     */
+    override readonly type: string | "SpotLight";
+
+    /**
+     * This is set equal to {@link THREE.Object3D.DEFAULT_UP | Object3D.DEFAULT_UP} (0, 1, 0), so that the light shines from the top down.
+     * @defaultValue `{@link Object3D.DEFAULT_UP}`
+     */
+    readonly position: Vector3;
+
+    /**
+     * The {@link SpotLight} points from its {@link SpotLight.position | position} to target.position.
+     * @remarks
+     * **Note**: For the target's position to be changed to anything other than the default,
+     * it must be added to the {@link Scene | scene} using
+     *
+     * ```typescript
+     * scene.add( light.target );
+     * ```
+     *
+     * This is so that the target's {@link Object3D.matrixWorld | matrixWorld} gets automatically updated each frame.
+     * It is also possible to set the target to be another object in the scene (anything with a {@link THREE.Object3D.position | position} property), like so:
+     * ```typescript
+     * const targetObject = new THREE.Object3D();
+     * scene.add(targetObject);
+     * light.target = targetObject;
+     * ```
+     * The {@link SpotLight} will now track the target object.
+     * @defaultValue `new THREE.Object3D()` _The default position of the target is *(0, 0, 0)*._
+     */
+    target: Object3D;
+
+    /**
+     * If set to `true` light will cast dynamic shadows.
+     * @remarks  **Warning**: This is expensive and requires tweaking to get shadows looking right. the {@link THREE.SpotLightShadow | SpotLightShadow} for details.
+     * @defaultValue `false`
+     */
+    override castShadow: boolean;
+
+    /**
+     * The light's intensity.
+     * @remarks Changing the intensity will also change the light's power.
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — intensity is the luminous intensity of the light measured in candela (cd).
+     * @remarks Expects a `Float`
+     * @defaultValue `1`
+     */
+    intensity: number;
+
+    /**
+     * When **Default mode** — When distance is zero, light does not attenuate. When distance is non-zero,
+     * light will attenuate linearly from maximum intensity at the light's position down to zero at this distance from the light.
+     *
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — When distance is zero,
+     * light will attenuate according to inverse-square law to infinite distance.
+     * When distance is non-zero, light will attenuate according to inverse-square law until near the distance cutoff,
+     * where it will then attenuate quickly and smoothly to `0`. Inherently, cutoffs are not physically correct.
+     * @remarks Expects a `Float`
+     * @defaultValue `0.0`
+     */
+    distance: number;
+
+    /**
+     * Maximum extent of the spotlight, in radians, from its direction.
+     * @remarks Should be no more than `Math.PI/2`.
+     * @remarks Expects a `Float`
+     * @defaultValue `Math.PI / 3`
+     */
+    angle: number;
+
+    /**
+     * The amount the light dims along the distance of the light.
+     * In context of physically-correct rendering the default value should not be changed.
+     * @remarks Expects a `Float`
+     * @defaultValue `2`
+     */
+    decay: number;
+
+    /**
+     * A {@link THREE.SpotLightShadow | SpotLightShadow} used to calculate shadows for this light.
+     * @defaultValue `new THREE.SpotLightShadow()`
+     */
+    shadow: SpotLightShadow;
+
+    /**
+     * The light's power.
+     * @remarks Changing the power will also change the light's intensity.
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** —  power is the luminous power of the light measured in lumens (lm).
+     * @remarks Expects a `Float`
+     */
+    power: number;
+
+    /**
+     * Percent of the {@link SpotLight} cone that is attenuated due to penumbra.
+     * @remarks Takes values between zero and 1.
+     * @remarks Expects a `Float`
+     * @defaultValue `0.0`
+     */
+    penumbra: number;
+
+    /**
+     * A {@link THREE.Texture | Texture} used to modulate the color of the light.
+     * The spot light color is mixed with the _RGB_ value of this texture, with a ratio corresponding to its alpha value.
+     * The cookie-like masking effect is reproduced using pixel values (0, 0, 0, 1-cookie_value).
+     * @remarks **Warning**: {@link SpotLight.map} is disabled if {@link SpotLight.castShadow} is `false`.
+     */
+    map: Texture | null;
+}

package/types/src/lights/SpotLightShadow.d.ts

@@ -0,0 +1,72 @@
+import { PerspectiveCamera } from "../cameras/PerspectiveCamera.js";
+import { LightShadow } from "./LightShadow.js";
+
+/**
+ * This is used internally by {@link SpotLight | SpotLights} for calculating shadows.
+ * @example
+ * ```typescript
+ * //Create a WebGLRenderer and turn on shadows in the renderer
+ * const renderer = new THREE.WebGLRenderer();
+ * renderer.shadowMap.enabled = true;
+ * renderer.shadowMap.type = THREE.PCFSoftShadowMap; // default THREE.PCFShadowMap
+ * //Create a SpotLight and turn on shadows for the light
+ * const light = new THREE.SpotLight(0xffffff);
+ * light.castShadow = true; // default false
+ * scene.add(light);
+ * //Set up shadow properties for the light
+ * light.shadow.mapSize.width = 512; // default
+ * light.shadow.mapSize.height = 512; // default
+ * light.shadow.camera.near = 0.5; // default
+ * light.shadow.camera.far = 500; // default
+ * light.shadow.focus = 1; // default
+ * //Create a sphere that cast shadows (but does not receive them)
+ * const sphereGeometry = new THREE.SphereGeometry(5, 32, 32);
+ * const sphereMaterial = new THREE.MeshStandardMaterial({
+ *     color: 0xff0000
+ * });
+ * const sphere = new THREE.Mesh(sphereGeometry, sphereMaterial);
+ * sphere.castShadow = true; //default is false
+ * sphere.receiveShadow = false; //default
+ * scene.add(sphere);
+ * //Create a plane that receives shadows (but does not cast them)
+ * const planeGeometry = new THREE.PlaneGeometry(20, 20, 32, 32);
+ * const planeMaterial = new THREE.MeshStandardMaterial({
+ *     color: 0x00ff00
+ * })
+ * const plane = new THREE.Mesh(planeGeometry, planeMaterial);
+ * plane.receiveShadow = true;
+ * scene.add(plane);
+ * //Create a helper for the shadow camera (optional)
+ * const helper = new THREE.CameraHelper(light.shadow.camera);
+ * scene.add(helper);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/lights/shadows/SpotLightShadow | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/SpotLightShadow.js | Source}
+ */
+export class SpotLightShadow extends LightShadow<PerspectiveCamera> {
+    /**
+     * Read-only flag to check if a given object is of type {@link SpotLightShadow}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isSpotLightShadow: true;
+
+    /**
+     * The light's view of the world.
+     * @remarks This is used to generate a depth map of the scene; objects behind other objects from the light's perspective will be in shadow.
+     * @remarks
+     * The {@link THREE.PerspectiveCamera.fov | fov} will track the {@link THREE.SpotLight.angle | angle} property
+     * of the owning {@link SpotLight | SpotLight} via the {@link SpotLightShadow.update | update} method.
+     * Similarly, the {@link THREE.PerspectiveCamera.aspect | aspect} property will track the aspect of the {@link LightShadow.mapSize | mapSize}.
+     * If the {@link SpotLight.distance | distance} property of the light is set, the {@link THREE.PerspectiveCamera.far | far} clipping plane will track that, otherwise it defaults to `500`.
+     * @defaultValue is a {@link THREE.PerspectiveCamera | PerspectiveCamera} with {@link THREE.PerspectiveCamera.near | near} clipping plane at `0.5`.
+     */
+    camera: PerspectiveCamera;
+
+    /**
+     * Used to focus the shadow camera.
+     * @remarks The camera's field of view is set as a percentage of the spotlight's field-of-view. Range is `[0, 1]`. 0`.
+     * @defaultValue `1`
+     */
+    focus: number;
+}

package/types/src/lights/webgpu/IESSpotLight.d.ts

@@ -0,0 +1,6 @@
+import { Texture } from "../../textures/Texture.js";
+import { SpotLight } from "../SpotLight.js";
+
+export default class IESSpotLight extends SpotLight {
+    iesMap: Texture | null;
+}

package/types/src/loaders/AnimationLoader.d.ts

@@ -0,0 +1,9 @@
+import { AnimationClip } from "../animation/AnimationClip.js";
+import { Loader } from "./Loader.js";
+import { LoadingManager } from "./LoadingManager.js";
+
+export class AnimationLoader extends Loader<AnimationClip[]> {
+    constructor(manager?: LoadingManager);
+
+    parse(json: readonly unknown[]): AnimationClip[];
+}

package/types/src/loaders/AudioLoader.d.ts

@@ -0,0 +1,6 @@
+import { Loader } from "./Loader.js";
+import { LoadingManager } from "./LoadingManager.js";
+
+export class AudioLoader extends Loader<AudioBuffer> {
+    constructor(manager?: LoadingManager);
+}

package/types/src/loaders/BufferGeometryLoader.d.ts

@@ -0,0 +1,10 @@
+import { BufferGeometry } from "../core/BufferGeometry.js";
+import { InstancedBufferGeometry } from "../core/InstancedBufferGeometry.js";
+import { Loader } from "./Loader.js";
+import { LoadingManager } from "./LoadingManager.js";
+
+export class BufferGeometryLoader extends Loader<InstancedBufferGeometry | BufferGeometry> {
+    constructor(manager?: LoadingManager);
+
+    parse(json: unknown): InstancedBufferGeometry | BufferGeometry;
+}

package/types/src/loaders/Cache.d.ts

@@ -0,0 +1,21 @@
+declare const Cache: {
+    /**
+     * @default false
+     */
+    enabled: boolean;
+
+    /**
+     * @default {}
+     */
+    files: any;
+
+    add(key: string, file: any): void;
+
+    get(key: string): any;
+
+    remove(key: string): void;
+
+    clear(): void;
+};
+
+export { Cache };

package/types/src/loaders/CompressedTextureLoader.d.ts

@@ -0,0 +1,14 @@
+import { CompressedTexture } from "../textures/CompressedTexture.js";
+import { Loader } from "./Loader.js";
+import { LoadingManager } from "./LoadingManager.js";
+
+export class CompressedTextureLoader extends Loader<CompressedTexture> {
+    constructor(manager?: LoadingManager);
+
+    load(
+        url: string,
+        onLoad?: (data: CompressedTexture) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): CompressedTexture;
+}

package/types/src/loaders/CubeTextureLoader.d.ts

@@ -0,0 +1,14 @@
+import { CubeTexture } from "../textures/CubeTexture.js";
+import { Loader } from "./Loader.js";
+import { LoadingManager } from "./LoadingManager.js";
+
+export class CubeTextureLoader extends Loader<CubeTexture, readonly string[]> {
+    constructor(manager?: LoadingManager);
+
+    load(
+        url: readonly string[],
+        onLoad?: (data: CubeTexture) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): CubeTexture;
+}

package/types/src/loaders/DataTextureLoader.d.ts

@@ -0,0 +1,14 @@
+import { DataTexture } from "../textures/DataTexture.js";
+import { Loader } from "./Loader.js";
+import { LoadingManager } from "./LoadingManager.js";
+
+export class DataTextureLoader extends Loader<DataTexture> {
+    constructor(manager?: LoadingManager);
+
+    load(
+        url: string,
+        onLoad?: (data: DataTexture, texData: object) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): DataTexture;
+}

package/types/src/loaders/FileLoader.d.ts

@@ -0,0 +1,19 @@
+import { Loader } from "./Loader.js";
+import { LoadingManager } from "./LoadingManager.js";
+
+export class FileLoader extends Loader<string | ArrayBuffer> {
+    constructor(manager?: LoadingManager);
+
+    load(
+        url: string,
+        onLoad?: (data: string | ArrayBuffer) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): void;
+
+    mimeType: undefined | MimeType;
+    responseType: undefined | string;
+
+    setMimeType(mimeType: MimeType): FileLoader;
+    setResponseType(responseType: string): FileLoader;
+}

package/types/src/loaders/ImageBitmapLoader.d.ts

@@ -0,0 +1,22 @@
+import { Loader } from "./Loader.js";
+import { LoadingManager } from "./LoadingManager.js";
+
+export class ImageBitmapLoader extends Loader<ImageBitmap> {
+    constructor(manager?: LoadingManager);
+
+    load(
+        url: string,
+        onLoad?: (data: ImageBitmap) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): void;
+
+    /**
+     * @default { premultiplyAlpha: 'none' }
+     */
+    options: undefined | object;
+
+    readonly isImageBitmapLoader: true;
+
+    setOptions(options: object): ImageBitmapLoader;
+}

package/types/src/loaders/ImageLoader.d.ts

@@ -0,0 +1,17 @@
+import { Loader } from "./Loader.js";
+import { LoadingManager } from "./LoadingManager.js";
+
+/**
+ * A loader for loading an image.
+ * Unlike other loaders, this one emits events instead of using predefined callbacks. So if you're interested in getting notified when things happen, you need to add listeners to the object.
+ */
+export class ImageLoader extends Loader<HTMLImageElement> {
+    constructor(manager?: LoadingManager);
+
+    load(
+        url: string,
+        onLoad?: (data: HTMLImageElement) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): HTMLImageElement;
+}

package/types/src/loaders/Loader.d.ts

@@ -0,0 +1,50 @@
+import { LoadingManager } from "./LoadingManager.js";
+
+/**
+ * Base class for implementing loaders.
+ */
+export class Loader<TData = unknown, TUrl = string> {
+    constructor(manager?: LoadingManager);
+
+    /**
+     * @default 'anonymous'
+     */
+    crossOrigin: string;
+
+    /**
+     * @default false
+     */
+    withCredentials: boolean;
+
+    /**
+     * @default ''
+     */
+    path: string;
+
+    /**
+     * @default ''
+     */
+    resourcePath: string;
+    manager: LoadingManager;
+
+    /**
+     * @default {}
+     */
+    requestHeader: { [header: string]: string };
+
+    load(
+        url: TUrl,
+        onLoad: (data: TData) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): void;
+    loadAsync(url: TUrl, onProgress?: (event: ProgressEvent) => void): Promise<TData>;
+
+    setCrossOrigin(crossOrigin: string): this;
+    setWithCredentials(value: boolean): this;
+    setPath(path: string): this;
+    setResourcePath(resourcePath: string): this;
+    setRequestHeader(requestHeader: { [header: string]: string }): this;
+
+    static DEFAULT_MATERIAL_NAME: string;
+}

package/types/src/loaders/LoaderUtils.d.ts

@@ -0,0 +1,10 @@
+export class LoaderUtils {
+    /**
+     * @deprecated decodeText() has been deprecated with r165 and will be removed with r175. Use TextDecoder instead.
+     */
+    static decodeText(array: BufferSource): string;
+
+    static extractUrlBase(url: string): string;
+
+    static resolveURL(url: string, path: string): string;
+}