@thatopen/components 2.0.8 → 2.0.10

package/dist/core/OrthoPerspectiveCamera/index.d.ts

@@ -4,23 +4,36 @@ import { SimpleCamera } from "..";
 import { NavigationMode, NavModeID, ProjectionManager } from "./src";
 export * from "./src";
 /**
- * A flexible camera that uses
- * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to
- * easily control the camera in 2D and 3D. It supports multiple navigation
- * modes, such as 2D floor plan navigation, first person and 3D orbit.
+ * A flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to easily control the camera in 2D and 3D. It supports multiple navigation modes, such as 2D floor plan navigation, first person and 3D orbit. This class extends the SimpleCamera class and adds additional functionality for managing different camera projections and navigation modes.
  */
 export declare class OrthoPerspectiveCamera extends SimpleCamera {
     /**
-     * The current {@link NavigationMode}.
+     * A ProjectionManager instance that manages the projection modes of the camera.
      */
-    _mode: NavigationMode | null;
     readonly projection: ProjectionManager;
+    /**
+     * A THREE.OrthographicCamera instance that represents the orthographic camera.
+     * This camera is used when the projection mode is set to orthographic.
+     */
     readonly threeOrtho: THREE.OrthographicCamera;
+    /**
+     * A THREE.PerspectiveCamera instance that represents the perspective camera.
+     * This camera is used when the projection mode is set to perspective.
+     */
     readonly threePersp: THREE.PerspectiveCamera;
     protected readonly _userInputButtons: any;
     protected readonly _frustumSize = 50;
     protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
+    protected _mode: NavigationMode | null;
     private previousSize;
+    /**
+   * Getter for the current navigation mode.
+   * Throws an error if the mode is not found or the camera is not initialized.
+   *
+   * @returns {NavigationMode} The current navigation mode.
+   *
+   * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
+   */
     get mode(): NavigationMode;
     constructor(components: Components);
     /** {@link Disposable.dispose} */

package/dist/core/OrthoPerspectiveCamera/src/first-person-mode.d.ts

@@ -1,8 +1,7 @@
 import { NavigationMode } from "./types";
 import { OrthoPerspectiveCamera } from "../index";
 /**
- * A {@link NavigationMode} that allows first person navigation,
- * simulating FPS video games.
+ * A {@link NavigationMode} that allows first person navigation, simulating FPS video games.
  */
 export declare class FirstPersonMode implements NavigationMode {
     private camera;

package/dist/core/OrthoPerspectiveCamera/src/orbit-mode.d.ts

@@ -1,8 +1,7 @@
 import { NavigationMode } from "./types";
 import { OrthoPerspectiveCamera } from "../index";
 /**
- * A {@link NavigationMode} that allows 3D navigation and panning
- * like in many 3D and CAD softwares.
+ * A {@link NavigationMode} that allows 3D navigation and panning like in many 3D and CAD softwares.
  */
 export declare class OrbitMode implements NavigationMode {
     camera: OrthoPerspectiveCamera;

package/dist/core/OrthoPerspectiveCamera/src/plan-mode.d.ts

@@ -1,8 +1,7 @@
 import { NavigationMode } from "./types";
 import { OrthoPerspectiveCamera } from "../index";
 /**
- * A {@link NavigationMode} that allows to navigate floorplans in 2D,
- * like many BIM tools.
+ * A {@link NavigationMode} that allows to navigate floorplans in 2D, like many BIM tools.
  */
 export declare class PlanMode implements NavigationMode {
     private camera;

package/dist/core/OrthoPerspectiveCamera/src/projections.d.ts

@@ -10,12 +10,20 @@ export declare class ProjectionManager {
      * Event that fires when the {@link CameraProjection} changes.
      */
     readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
+    /**
+     * Current projection mode of the camera.
+     * Default is "Perspective".
+     */
     current: CameraProjection;
+    /**
+     * The camera controlled by this ProjectionManager.
+     * It can be either a PerspectiveCamera or an OrthographicCamera.
+     */
     camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    private _component;
-    private _previousDistance;
     /** Match Ortho zoom with Perspective distance when changing projection mode */
     matchOrthoDistanceEnabled: boolean;
+    private _component;
+    private _previousDistance;
     constructor(camera: OrthoPerspectiveCamera);
     /**
      * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.

package/dist/core/OrthoPerspectiveCamera/src/types.d.ts

@@ -7,8 +7,7 @@ export type CameraProjection = "Perspective" | "Orthographic";
  */
 export type NavModeID = "Orbit" | "FirstPerson" | "Plan";
 /**
- * An object that determines the behavior of the camera controls
- * and the user input (e.g. 2D floor plan mode, first person mode, etc).
+ * An object that determines the behavior of the camera controls and the user input (e.g. 2D floor plan mode, first person mode, etc).
  */
 export interface NavigationMode {
     /** The unique ID of this navigation mode. */

package/dist/core/Raycasters/index.d.ts

@@ -1,13 +1,42 @@
 import { Component, Disposable, World, Event } from "../Types";
 import { SimpleRaycaster } from "./src";
 import { Components } from "../Components";
+/**
+ * A component that manages raycasters for different worlds. It uses a Map to store raycasters for each world, and automatically disposes them when the world is disposed.
+ */
 export declare class Raycasters extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
     static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
+    /** {@link Component.enabled} */
     enabled: boolean;
+    /**
+     * A Map that stores raycasters for each world.
+     * The key is the world's UUID, and the value is the corresponding SimpleRaycaster instance.
+     */
     list: Map<string, SimpleRaycaster>;
+    /** {@link Disposable.onDisposed} */
     onDisposed: Event<unknown>;
     constructor(components: Components);
+    /**
+     * Retrieves a SimpleRaycaster instance for the given world.
+     * If a SimpleRaycaster instance already exists for the world, it will be returned.
+     * Otherwise, a new SimpleRaycaster instance will be created and added to the list.
+     *
+     * @param world - The world for which to retrieve or create a SimpleRaycaster instance.
+     * @returns The SimpleRaycaster instance for the given world.
+     */
     get(world: World): SimpleRaycaster;
+    /**
+     * Deletes the SimpleRaycaster instance associated with the given world.
+     * If a SimpleRaycaster instance exists for the given world, it will be disposed and removed from the list.
+     *
+     * @param world - The world for which to delete the SimpleRaycaster instance.
+     * @returns {void}
+     */
     delete(world: World): void;
+    /** {@link Disposable.dispose} */
     dispose(): void;
 }

package/dist/core/Raycasters/src/simple-raycaster.d.ts

@@ -10,12 +10,21 @@ import { Mouse } from "./mouse";
 export declare class SimpleRaycaster implements Disposable {
     /** {@link Component.enabled} */
     enabled: boolean;
+    /** The components instance to which this Raycaster belongs. */
     components: Components;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
     /** The position of the mouse in the screen. */
     readonly mouse: Mouse;
+    /**
+     * A reference to the Three.js Raycaster instance.
+     * This is used for raycasting operations.
+     */
     readonly three: THREE.Raycaster;
+    /**
+     * A reference to the world instance to which this Raycaster belongs.
+     * This is used to access the camera and meshes.
+     */
     world: World;
     constructor(components: Components, world: World);
     /** {@link Disposable.dispose} */
@@ -30,6 +39,15 @@ export declare class SimpleRaycaster implements Disposable {
      * {@link Components.meshes}.
      */
     castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
+    /**
+   * Casts a ray from a given origin in a given direction and returns the first item found.
+   * This method also takes into account the clipping planes used by the renderer.
+   *
+   * @param origin - The origin of the ray.
+   * @param direction - The direction of the ray.
+   * @param items - The meshes to query. If not provided, it will query all the meshes stored in {@link World.meshes}.
+   * @returns The first intersection found or `null` if no intersection was found.
+   */
     castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
     private intersect;
     private filterClippingPlanes;

package/dist/core/Types/src/async-event.d.ts

@@ -1,11 +1,5 @@
 /**
- * Simple event handler by
- * [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540).
- * Keep in mind that:
- * - If you want to remove it later, you might want to declare the callback as
- * an object.
- * - If you want to maintain the reference to `this`, you will need to declare
- * the callback as an arrow function.
+ * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to `this`, you will need to declare the callback as an arrow function.
  */
 export declare class AsyncEvent<T> {
     /**

package/dist/core/Types/src/base-camera.d.ts

@@ -2,10 +2,27 @@ import * as THREE from "three";
 import CameraControls from "camera-controls";
 import { BaseWorldItem } from "./base-world-item";
 import { CameraControllable } from "./interfaces";
+/**
+ * Abstract class representing a camera in the 3D world. All cameras should use this class as a base.
+ */
 export declare abstract class BaseCamera extends BaseWorldItem {
+    /**
+     * Whether the camera is enabled or not.
+     */
     abstract enabled: boolean;
+    /**
+     * The Three.js camera instance.
+     */
     abstract three: THREE.Camera;
+    /**
+     * Optional CameraControls instance for controlling the camera.
+     * This property is only available if the camera is controllable.
+     */
     abstract controls?: CameraControls;
-    /** Whether is instance is {@link CameraControllable}. */
+    /**
+     * Checks whether the instance is {@link CameraControllable}.
+     *
+     * @returns True if the instance is controllable, false otherwise.
+     */
     hasCameraControls: () => this is CameraControllable;
 }

package/dist/core/Types/src/base-renderer.d.ts

@@ -3,7 +3,16 @@ import { Vector2 } from "three";
 import { Event } from "./event";
 import { BaseWorldItem } from "./base-world-item";
 import { Disposable, Resizeable, Updateable } from "./interfaces";
+/**
+ * Abstract class representing a renderer for a 3D world. All renderers should use this class as a base.
+ */
 export declare abstract class BaseRenderer extends BaseWorldItem implements Updateable, Disposable, Resizeable {
+    /**
+     * The three.js WebGLRenderer instance associated with this renderer.
+     *
+     * @abstract
+     * @type {THREE.WebGLRenderer}
+     */
     abstract three: THREE.WebGLRenderer;
     /** {@link Updateable.onBeforeUpdate} */
     onAfterUpdate: Event<unknown>;
@@ -11,30 +20,46 @@ export declare abstract class BaseRenderer extends BaseWorldItem implements Upda
     onBeforeUpdate: Event<unknown>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<undefined>;
+    /** {@link Resizeable.onResize} */
     readonly onResize: Event<THREE.Vector2>;
     /**
      * Event that fires when there has been a change to the list of clipping
      * planes used by the active renderer.
      */
     readonly onClippingPlanesUpdated: Event<unknown>;
+    /** {@link Updateable.update} */
     abstract update(delta?: number): void | Promise<void>;
+    /** {@link Disposable.dispose} */
     abstract dispose(): void;
+    /** {@link Resizeable.getSize} */
     abstract getSize(): Vector2;
+    /** {@link Resizeable.resize} */
     abstract resize(size: Vector2 | undefined): void;
     /**
-     * The list of [clipping planes](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes) used by this
-     * instance of the renderer.
+     * The list of [clipping planes](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes) used by this instance of the renderer.
      */
     clippingPlanes: THREE.Plane[];
     /**
-     * Forces the update of the clipping planes and all components that depend
-     * on them that are subscribed to `onClippingPlanesUpdated`.
-     */
+   * Updates the clipping planes and triggers the `onClippingPlanesUpdated` event.
+   *
+   * @remarks
+   * This method is typically called when there is a change to the list of clipping planes
+   * used by the active renderer.
+   */
     updateClippingPlanes(): void;
     /**
-     * Adds or removes a
-     * [clipping plane](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes)
-     * to the renderer.
-     */
+   * Sets or removes a clipping plane from the renderer.
+   *
+   * @param active - A boolean indicating whether the clipping plane should be active or not.
+   * @param plane - The clipping plane to be added or removed.
+   * @param isLocal - An optional boolean indicating whether the clipping plane is local to the object. If not provided, it defaults to `false`.
+   *
+   * @remarks
+   * This method adds or removes a clipping plane from the `clippingPlanes` array.
+   * If `active` is `true` and the plane is not already in the array, it is added.
+   * If `active` is `false` and the plane is in the array, it is removed.
+   * The `three.clippingPlanes` property is then updated to reflect the current state of the `clippingPlanes` array,
+   * excluding any planes marked as local.
+   */
     setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
 }

package/dist/core/Types/src/base-scene.d.ts

@@ -3,9 +3,16 @@ import { Disposable } from "./interfaces";
 import { Event } from "./event";
 import { Components } from "../../Components";
 import { BaseWorldItem } from "./base-world-item";
+/**
+ * Abstract class representing a base scene in the application. All scenes should use this class as a base.
+ */
 export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
+    /**
+    * Abstract property representing the three.js object associated with this scene.
+    * It should be implemented by subclasses.
+    */
     abstract three: THREE.Object3D;
     protected constructor(components: Components);
     /** {@link Disposable.dispose} */

package/dist/core/Types/src/base-world-item.d.ts

@@ -3,15 +3,21 @@ import { World } from "./world";
 import { Event } from "./event";
 import { Components } from "../../Components";
 /**
- * One of the elements that make a world. It can be either a scene, a camera
- * or a renderer.
+ * One of the elements that make a world. It can be either a scene, a camera or a renderer.
  */
 export declare abstract class BaseWorldItem extends Base {
     readonly worlds: Map<string, World>;
+    /**
+     * Event that is triggered when a world is added or removed from the `worlds` map.
+     * The event payload contains the world instance and the action ("added" or "removed").
+     */
     readonly onWorldChanged: Event<{
         world: World;
         action: "added" | "removed";
     }>;
+    /**
+     * The current world this item is associated with. It can be null if no world is currently active.
+     */
     currentWorld: World | null;
     protected constructor(components: Components);
 }

package/dist/core/Types/src/base.d.ts

@@ -1,7 +1,7 @@
 import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
 import { Components } from "../../Components";
 /**
- * Base class of the library. Useful for finding out the interfaces it implements.
+ * Base class of the library. Useful for finding out the interfaces something implements.
  */
 export declare abstract class Base {
     components: Components;

package/dist/core/Types/src/component.d.ts

@@ -1,11 +1,6 @@
 import { Base } from "./base";
 /**
- * Components are the building blocks of this library. Components are singleton
- * elements that contain specific functionality. For instance, the SimpleClipper
- * Component can create, delete and handle 3D clipping planes. Components must be
- * unique (they can't be instanced more than once), and have a static UUID that
- * identifies them uniquely. The can be accessed globally using the {@link Components}
- * instance.
+ * Components are the building blocks of this library. Components are singleton elements that contain specific functionality. For instance, the Clipper Component can create, delete and handle 3D clipping planes. Components must be unique (they can't be instanced more than once per Components instance), and have a static UUID that identifies them uniquely. The can be accessed globally using the {@link Components} instance.
  */
 export declare abstract class Component extends Base {
     /**

package/dist/core/Types/src/event.d.ts

@@ -1,11 +1,5 @@
 /**
- * Simple event handler by
- * [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540).
- * Keep in mind that:
- * - If you want to remove it later, you might want to declare the callback as
- * an object.
- * - If you want to maintain the reference to `this`, you will need to declare
- * the callback as an arrow function.
+ * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to `this`, you will need to declare the callback as an arrow function.
  */
 export declare class Event<T> {
     /**

package/dist/core/Types/src/interfaces.d.ts

@@ -2,11 +2,7 @@ import * as THREE from "three";
 import CameraControls from "camera-controls";
 import { Event } from "./event";
 /**
- * Whether this component has to be manually destroyed once you are done with
- * it to prevent
- * [memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
- * This also ensures that the DOM events created by that component will be
- * cleaned up.
+ * Whether this component has to be manually destroyed once you are done with it to prevent [memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects). This also ensures that the DOM events created by that component will be cleaned up.
  */
 export interface Disposable {
     /**
@@ -14,13 +10,11 @@ export interface Disposable {
      * [memory leak](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
      */
     dispose: () => void | Promise<void>;
-    /** Fired after the tool has been {@link Disposable.dispose()}  */
+    /** Fired after the tool has been disposed.  */
     readonly onDisposed: Event<any>;
 }
 /**
- * Whether the geometric representation of this component can be
- * hidden or shown in the
- * [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
+ * Whether the geometric representation of this component can be hidden or shown in the [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
  */
 export interface Hideable {
     /**
@@ -31,11 +25,7 @@ export interface Hideable {
     visible: boolean;
 }
 /**
- * Whether this component can be resized. The meaning of this can vary depending
- * on the component: resizing a
- * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
- * component could mean changing its resolution, whereas resizing a
- * [Mesh](https://threejs.org/docs/#api/en/objects/Mesh) would change its scale.
+ * Whether this component can be resized. The meaning of this can vary depending on the component: resizing a [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer) component could mean changing its resolution, whereas resizing a [Mesh](https://threejs.org/docs/#api/en/objects/Mesh) would change its scale.
  */
 export interface Resizeable {
     /**
@@ -73,9 +63,7 @@ export interface Progress {
     total: number;
 }
 /**
- * Whether this component supports create and destroy operations. This generally
- * applies for components that work with instances, such as clipping planes or
- * dimensions.
+ * Whether this component supports create and destroy operations. This generally applies for components that work with instances, such as clipping planes or dimensions.
  */
 export interface Createable {
     /** Creates a new instance of an element (e.g. a new Dimension). */
@@ -108,16 +96,13 @@ export interface Configurable<T extends Record<string, any>> {
      */
     config: Required<T>;
 }
-/**
- * An interface to make [three-mesh-bvh](https://github.com/gkjohnson/three-mesh-bvh) compatible with typescript.
- */
-export interface BVHGeometry extends THREE.BufferGeometry {
-    boundsTree: Object | undefined;
-    disposeBoundsTree: () => void;
-}
 /**
  * Whether a camera uses the Camera Controls library.
  */
 export interface CameraControllable {
+    /**
+     * An instance of CameraControls that provides camera control functionalities.
+     * This instance is used to manipulate the camera.
+     */
     controls: CameraControls;
 }

package/dist/core/Types/src/world.d.ts

@@ -3,11 +3,32 @@ import { BaseScene } from "./base-scene";
 import { BaseCamera } from "./base-camera";
 import { BaseRenderer } from "./base-renderer";
 import { Updateable, Disposable } from "./interfaces";
+/**
+ * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
+ */
 export interface World extends Disposable, Updateable {
+    /**
+     * A set of meshes present in the world. This is taken into account for operations like raycasting.
+     */
     meshes: Set<THREE.Mesh>;
+    /**
+     * The base scene of the world.
+     */
     scene: BaseScene;
+    /**
+     * The base camera of the world.
+     */
     camera: BaseCamera;
+    /**
+     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
+     */
     renderer: BaseRenderer | null;
+    /**
+     * A unique identifier for the world.
+     */
     uuid: string;
+    /**
+     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
+     */
     isDisposing: boolean;
 }

package/dist/core/Worlds/index.d.ts

@@ -2,38 +2,37 @@ import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera,
 import { Components } from "../Components";
 import { SimpleWorld } from "./src";
 export * from "./src";
+/**
+ * A class representing a collection of worlds within a game engine. It manages the creation, deletion, and update of worlds.
+ */
 export declare class Worlds extends Component implements Updateable, Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
     static readonly uuid: "fdb61dc4-2ec1-4966-b83d-54ea795fad4a";
-    /**
-     * Event triggered after the update process of all worlds.
-     * Subscribers can listen to this event to perform actions post-update.
-     */
+    /** {@link Updateable.onAfterUpdate} */
     readonly onAfterUpdate: Event<unknown>;
-    /**
-     * Event triggered before the update process of all worlds.
-     * Subscribers can listen to this event to perform actions pre-update.
-     */
+    /** {@link Updateable.onBeforeUpdate} */
     readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /**
-     * Event triggered when the Worlds component is disposed.
-     * Subscribers can listen to this event to perform cleanup actions.
+     * An event that is triggered when a new world is created.
+     * The event passes the newly created world as a parameter.
      */
-    readonly onDisposed: Event<unknown>;
     readonly onWorldCreated: Event<World>;
+    /**
+     * An event that is triggered when a world is deleted.
+     * The event passes the UUID of the deleted world as a parameter.
+     */
     readonly onWorldDeleted: Event<string>;
     /**
      * A collection of worlds managed by this component.
      * The key is the unique identifier (UUID) of the world, and the value is the World instance.
      */
     list: Map<string, World>;
-    /**
-     * A flag indicating whether the Worlds component is enabled.
-     * If false, the update process will be skipped.
-     */
+    /** {@link Component.enabled} */
     enabled: boolean;
     constructor(components: Components);
     /**
@@ -46,7 +45,24 @@ export declare class Worlds extends Component implements Updateable, Disposable
      * @throws {Error} - Throws an error if a world with the same UUID already exists in the list.
      */
     create<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer>(): SimpleWorld<T, U, S>;
+    /**
+   * Deletes a world from the list of worlds.
+   *
+   * @param {World} world - The world to be deleted.
+   *
+   * @throws {Error} - Throws an error if the provided world is not found in the list.
+   *
+   * @returns {void}
+   */
     delete(world: World): void;
+    /**
+   * Disposes of the Worlds component and all its managed worlds.
+   * This method sets the enabled flag to false, disposes of all worlds, clears the list,
+   * and triggers the onDisposed event.
+   *
+   * @returns {void}
+   */
     dispose(): void;
+    /** {@link Updateable.update} */
     update(delta?: number): void | Promise<void>;
 }

package/dist/core/Worlds/src/simple-camera.d.ts

@@ -3,19 +3,24 @@ import CameraControls from "camera-controls";
 import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
 import { Components } from "../../Components";
 /**
- * A basic camera that uses
- * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to
- * easily control the camera in 2D and 3D. Check out it's API to find out
- * what features it offers.
+ * A basic camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to easily control the camera in 2D and 3D. Check out it's API to find out what features it offers.
  */
 export declare class SimpleCamera extends BaseCamera implements Updateable, Disposable {
     /** {@link Updateable.onBeforeUpdate} */
     readonly onBeforeUpdate: Event<SimpleCamera>;
     /** {@link Updateable.onAfterUpdate} */
     readonly onAfterUpdate: Event<SimpleCamera>;
+    /**
+     * Event that is triggered when the aspect of the camera has been updated.
+     * This event is useful when you need to perform actions after the aspect of the camera has been changed.
+     */
     readonly onAspectUpdated: Event<unknown>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<string>;
+    /**
+     * A three.js PerspectiveCamera or OrthographicCamera instance.
+     * This camera is used for rendering the scene.
+     */
     three: THREE.PerspectiveCamera | THREE.OrthographicCamera;
     private _allControls;
     /**
@@ -25,9 +30,20 @@ export declare class SimpleCamera extends BaseCamera implements Updateable, Disp
      * object to move, rotate, look at objects, etc.
      */
     get controls(): CameraControls;
-    /** {@link Component.enabled} */
+    /**
+     * Getter for the enabled state of the camera controls.
+     * If the current world is null, it returns false.
+     * Otherwise, it returns the enabled state of the camera controls.
+     *
+     * @returns {boolean} The enabled state of the camera controls.
+     */
     get enabled(): boolean;
-    /** {@link Component.enabled} */
+    /**
+     * Setter for the enabled state of the camera controls.
+     * If the current world is not null, it sets the enabled state of the camera controls to the provided value.
+     *
+     * @param {boolean} enabled - The new enabled state of the camera controls.
+     */
     set enabled(enabled: boolean);
     constructor(components: Components);
     /** {@link Disposable.dispose} */