@thatopen/components 2.4.11 → 3.1.1

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

@@ -1,54 +0,0 @@
-import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer, DataMap } from "../Types";
-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. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Worlds). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/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";
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * 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: DataMap<string, World>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Creates a new instance of a SimpleWorld and adds it to the list of worlds.
-     *
-     * @template T - The type of the scene, extending from BaseScene. Defaults to BaseScene.
-     * @template U - The type of the camera, extending from BaseCamera. Defaults to BaseCamera.
-     * @template S - The type of the renderer, extending from BaseRenderer. Defaults to BaseRenderer.
-     *
-     * @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.
-     */
-    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.
-     */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(delta?: number): void | Promise<void>;
-}

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

@@ -1,5 +0,0 @@
-export * from "./simple-world";
-export * from "./simple-scene";
-export * from "./simple-renderer";
-export * from "./simple-camera";
-export * from "./simple-scene-config";

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

@@ -1,62 +0,0 @@
-import * as THREE from "three";
-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 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;
-    /**
-     * The object that controls the camera. An instance of
-     * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls).
-     * Transforming the camera directly will have no effect: you need to use this
-     * object to move, rotate, look at objects, etc.
-     */
-    get controls(): CameraControls;
-    /**
-     * 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;
-    /**
-     * 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} */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(_delta: number): void;
-    /**
-     * Updates the aspect of the camera to match the size of the
-     * {@link Components.renderer}.
-     */
-    updateAspect: () => void;
-    private setupCamera;
-    private newCameraControls;
-    private setupEvents;
-    private static getSubsetOfThree;
-}

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

@@ -1,54 +0,0 @@
-import * as THREE from "three";
-import { BaseRenderer, Event } from "../../Types";
-import { Components } from "../../Components";
-/**
- * A basic renderer capable of rendering [Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
- */
-export declare class SimpleRenderer extends BaseRenderer {
-    /**
-     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
-     * Default is `true`.
-     */
-    enabled: boolean;
-    /**
-     * The HTML container of the THREE.js canvas where the scene is rendered.
-     */
-    container: HTMLElement;
-    /**
-     * The THREE.js WebGLRenderer instance.
-     */
-    three: THREE.WebGLRenderer;
-    protected _canvas: HTMLCanvasElement;
-    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
-    protected _resizeObserver: ResizeObserver | null;
-    protected onContainerUpdated: Event<unknown>;
-    private _resizing;
-    /**
-     * Constructor for the SimpleRenderer class.
-     *
-     * @param components - The components instance.
-     * @param container - The HTML container where the THREE.js canvas will be rendered.
-     * @param parameters - Optional parameters for the THREE.js WebGLRenderer.
-     */
-    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
-    /** {@link Updateable.update} */
-    update(): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Resizeable.getSize}. */
-    getSize(): THREE.Vector2;
-    /** {@link Resizeable.resize} */
-    resize: (size?: THREE.Vector2) => void;
-    /**
-     * Sets up and manages the event listeners for the renderer.
-     *
-     * @param active - A boolean indicating whether to activate or deactivate the event listeners.
-     *
-     * @throws Will throw an error if the renderer does not have an HTML container.
-     */
-    setupEvents(active: boolean): void;
-    private resizeEvent;
-    private setupRenderer;
-    private onContextLost;
-    private onContextBack;
-}

package/dist/core/Worlds/src/simple-scene-config.d.ts

@@ -1,59 +0,0 @@
-import * as THREE from "three";
-import { SimpleScene } from "./simple-scene";
-import { ColorSettingsControl, NumberSettingControl, Vector3SettingControl } from "../../Types";
-import { Configurator } from "../../ConfigManager";
-type SimpleSceneConfigType = {
-    backgroundColor: ColorSettingsControl;
-    ambientLight: {
-        color: ColorSettingsControl;
-        intensity: NumberSettingControl;
-    };
-    directionalLight: {
-        color: ColorSettingsControl;
-        intensity: NumberSettingControl;
-        position: Vector3SettingControl;
-    };
-};
-declare class DirectionalLightConfig {
-    private _list;
-    private _scene;
-    constructor(list: SimpleSceneConfigType, scene: SimpleScene);
-    get color(): THREE.Color;
-    set color(value: THREE.Color);
-    get intensity(): number;
-    set intensity(value: number);
-    get position(): THREE.Vector3;
-    set position(value: THREE.Vector3);
-}
-declare class AmbientLightConfig {
-    private _list;
-    private _scene;
-    constructor(list: SimpleSceneConfigType, scene: SimpleScene);
-    get color(): THREE.Color;
-    set color(value: THREE.Color);
-    get intensity(): number;
-    set intensity(value: number);
-}
-/**
- * Configuration interface for the {@link SimpleScene}.
- */
-export interface SimpleSceneConfig {
-    backgroundColor: THREE.Color;
-    directionalLight: {
-        color: THREE.Color;
-        intensity: number;
-        position: THREE.Vector3;
-    };
-    ambientLight: {
-        color: THREE.Color;
-        intensity: number;
-    };
-}
-export declare class SimpleSceneConfigManager extends Configurator<SimpleScene, SimpleSceneConfigType> {
-    protected _config: SimpleSceneConfigType;
-    ambientLight: AmbientLightConfig;
-    directionalLight: DirectionalLightConfig;
-    get backgroundColor(): THREE.Color;
-    set backgroundColor(value: THREE.Color);
-}
-export {};

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

@@ -1,25 +0,0 @@
-import * as THREE from "three";
-import { BaseScene, Configurable, Event } from "../../Types";
-import { Components } from "../../Components";
-import { SimpleSceneConfig, SimpleSceneConfigManager } from "./simple-scene-config";
-/**
- * A basic 3D [scene](https://threejs.org/docs/#api/en/scenes/Scene) to add objects hierarchically, and easily dispose them when you are finished with it.
- */
-export declare class SimpleScene extends BaseScene implements Configurable<SimpleSceneConfigManager, SimpleSceneConfig> {
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    /**
-     * The underlying Three.js scene object.
-     * It is used to define the 3D space containing objects, lights, and cameras.
-     */
-    three: THREE.Scene;
-    /** {@link Configurable.config} */
-    config: SimpleSceneConfigManager;
-    protected _defaultConfig: SimpleSceneConfig;
-    constructor(components: Components);
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<SimpleSceneConfig>): void;
-    dispose(): void;
-}

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

@@ -1,79 +0,0 @@
-import * as THREE from "three";
-import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
-/**
- * A class representing a simple world in a 3D environment. It extends the Base class and implements the World interface.
- *
- * @template T - The type of the scene. Default is BaseScene.
- * @template U - The type of the camera. Default is BaseCamera.
- * @template S - The type of the renderer. Default is BaseRenderer.
- */
-export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World, Disposable, Updateable {
-    /**
-     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh). These meshes will be taken into account in operations like raycasting.
-     */
-    readonly meshes: Set<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Indicates whether the world is currently being disposed. This is useful to prevent trying to access world's elements when it's being disposed, which could cause errors when you dispose a world.
-     */
-    isDisposing: boolean;
-    /**
-     * Indicates whether the world is currently enabled.
-     * When disabled, the world will not be updated.
-     */
-    enabled: boolean;
-    /**
-     * A unique identifier for the world. Is not meant to be changed at any moment.
-     */
-    readonly uuid: string;
-    /**
-     * An optional name for the world.
-     */
-    name?: string;
-    private _scene?;
-    private _camera?;
-    private _renderer;
-    /**
-     * Getter for the scene. If no scene is initialized, it throws an error.
-     * @returns The current scene.
-     */
-    get scene(): T;
-    /**
-     * Setter for the scene. It sets the current scene, adds the world to the scene's worlds set,
-     * sets the current world in the scene, and triggers the scene's onWorldChanged event with the added action.
-     * @param scene - The new scene to be set.
-     */
-    set scene(scene: T);
-    /**
-     * Getter for the camera. If no camera is initialized, it throws an error.
-     * @returns The current camera.
-     */
-    get camera(): U;
-    /**
-     * Setter for the camera. It sets the current camera, adds the world to the camera's worlds set,
-     * sets the current world in the camera, and triggers the camera's onWorldChanged event with the added action.
-     * @param camera - The new camera to be set.
-     */
-    set camera(camera: U);
-    /**
-     * Getter for the renderer.
-     * @returns The current renderer or null if no renderer is set. Some worlds don't need a renderer to work (when your mail goal is not to display a 3D viewport to the user).
-     */
-    get renderer(): S | null;
-    /**
-     * Setter for the renderer. It sets the current renderer, adds the world to the renderer's worlds set,
-     * sets the current world in the renderer, and triggers the renderer's onWorldChanged event with the added action.
-     * If a new renderer is set, it also triggers the onWorldChanged event with the removed action for the old renderer.
-     * @param renderer - The new renderer to be set or null to remove the current renderer.
-     */
-    set renderer(renderer: S | null);
-    /** {@link Updateable.update} */
-    update(delta?: number): void;
-    /** {@link Disposable.dispose} */
-    dispose(disposeResources?: boolean): void;
-}

package/dist/core/index.d.ts

@@ -1,13 +0,0 @@
-export * from "./Components";
-export * from "./Disposer";
-export * from "./ShadowedScene";
-export * from "./Raycasters";
-export * from "./Types";
-export * from "./Worlds";
-export * from "./Grids";
-export * from "./Clipper";
-export * from "./Cullers";
-export * from "./Viewpoints";
-export * from "./MiniMap";
-export * from "./OrthoPerspectiveCamera";
-export * from "./ConfigManager";

package/dist/fragments/BoundingBoxer/index.d.ts

@@ -1,208 +0,0 @@
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Component, Components, Disposable, Event } from "../../core";
-/**
- * A simple implementation of bounding box that works for fragments. The resulting bbox is not 100% precise, but it's fast, and should suffice for general use cases such as camera zooming or general boundary determination. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/BoundingBoxer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/BoundingBoxer).
- */
-export declare class BoundingBoxer extends Component implements Disposable {
-    static readonly uuid: "d1444724-dba6-4cdd-a0c7-68ee1450d166";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    private _absoluteMin;
-    private _absoluteMax;
-    private _meshes;
-    constructor(components: Components);
-    /**
-     * A static method to calculate the dimensions of a given bounding box.
-     *
-     * @param bbox - The bounding box to calculate the dimensions for.
-     * @returns An object containing the width, height, depth, and center of the bounding box.
-     */
-    static getDimensions(bbox: THREE.Box3): {
-        width: number;
-        height: number;
-        depth: number;
-        center: THREE.Vector3;
-    };
-    /**
-     * A static method to create a new bounding box boundary.
-     *
-     * @param positive - A boolean indicating whether to create a boundary for positive or negative values.
-     * @returns A new THREE.Vector3 representing the boundary.
-     *
-     * @remarks
-     * This method is used to create a new boundary for calculating bounding boxes.
-     * It sets the x, y, and z components of the returned vector to positive or negative infinity,
-     * depending on the value of the `positive` parameter.
-     *
-     * @example
-     * ```typescript
-     * const positiveBound = BoundingBoxer.newBound(true);
-     * console.log(positiveBound); // Output: Vector3 { x: Infinity, y: Infinity, z: Infinity }
-     *
-     * const negativeBound = BoundingBoxer.newBound(false);
-     * console.log(negativeBound); // Output: Vector3 { x: -Infinity, y: -Infinity, z: -Infinity }
-     * ```
-     */
-    static newBound(positive: boolean): THREE.Vector3;
-    /**
-     * A static method to calculate the bounding box of a set of points.
-     *
-     * @param points - An array of THREE.Vector3 representing the points.
-     * @param min - An optional THREE.Vector3 representing the minimum bounds. If not provided, it will be calculated.
-     * @param max - An optional THREE.Vector3 representing the maximum bounds. If not provided, it will be calculated.
-     * @returns A THREE.Box3 representing the bounding box of the given points.
-     *
-     * @remarks
-     * This method calculates the bounding box of a set of points by iterating through each point and updating the minimum and maximum bounds accordingly.
-     * If the `min` or `max` parameters are provided, they will be used as the initial bounds. Otherwise, the initial bounds will be set to positive and negative infinity.
-     *
-     * @example
-     * ```typescript
-     * const points = [
-     *   new THREE.Vector3(1, 2, 3),
-     *   new THREE.Vector3(4, 5, 6),
-     *   new THREE.Vector3(7, 8, 9),
-     * ];
-     *
-     * const bbox = BoundingBoxer.getBounds(points);
-     * console.log(bbox); // Output: Box3 { min: Vector3 { x: 1, y: 2, z: 3 }, max: Vector3 { x: 7, y: 8, z: 9 } }
-     * ```
-     */
-    static getBounds(points: THREE.Vector3[], min?: THREE.Vector3, max?: THREE.Vector3): THREE.Box3;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Returns the bounding box of the calculated fragments.
-     *
-     * @returns A new THREE.Box3 instance representing the bounding box.
-     *
-     * @remarks
-     * This method clones the internal minimum and maximum vectors and returns a new THREE.Box3 instance.
-     * The returned box represents the bounding box of the calculated fragments.
-     *
-     * @example
-     * ```typescript
-     * const boundingBox = boundingBoxer.get();
-     * console.log(boundingBox); // Output: Box3 { min: Vector3 { x: -10, y: -10, z: -10 }, max: Vector3 { x: 10, y: 10, z: 10 } }
-     * ```
-     */
-    get(): THREE.Box3;
-    /**
-     * Calculates and returns a sphere that encompasses the entire bounding box.
-     *
-     * @returns A new THREE.Sphere instance representing the calculated sphere.
-     *
-     * @remarks
-     * This method calculates the center and radius of a sphere that encompasses the entire bounding box.
-     * The center is calculated as the midpoint between the minimum and maximum bounds of the bounding box.
-     * The radius is calculated as the distance from the center to the minimum bound.
-     *
-     * @example
-     * ```typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * boundingBoxer.add(fragmentsGroup);
-     * const boundingSphere = boundingBoxer.getSphere();
-     * console.log(boundingSphere); // Output: Sphere { center: Vector3 { x: 0, y: 0, z: 0 }, radius: 10 }
-     * ```
-     */
-    getSphere(): THREE.Sphere;
-    /**
-     * Returns a THREE.Mesh instance representing the bounding box.
-     *
-     * @returns A new THREE.Mesh instance representing the bounding box.
-     *
-     * @remarks
-     * This method calculates the dimensions of the bounding box using the `getDimensions` method.
-     * It then creates a new THREE.BoxGeometry with the calculated dimensions.
-     * A new THREE.Mesh is created using the box geometry, and it is added to the `_meshes` array.
-     * The position of the mesh is set to the center of the bounding box.
-     *
-     * @example
-     * ```typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * boundingBoxer.add(fragmentsGroup);
-     * const boundingBoxMesh = boundingBoxer.getMesh();
-     * scene.add(boundingBoxMesh);
-     * ```
-     */
-    getMesh(): THREE.Mesh<THREE.BoxGeometry, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
-    /**
-     * Resets the internal minimum and maximum vectors to positive and negative infinity, respectively.
-     * This method is used to prepare the BoundingBoxer for a new set of fragments.
-     *
-     * @remarks
-     * This method is called when a new set of fragments is added to the BoundingBoxer.
-     * It ensures that the bounding box calculations are accurate and up-to-date.
-     *
-     * @example
-     * ```typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * boundingBoxer.add(fragmentsGroup);
-     * // ...
-     * boundingBoxer.reset();
-     * ```
-     */
-    reset(): void;
-    /**
-     * Adds a FragmentsGroup to the BoundingBoxer.
-     *
-     * @param group - The FragmentsGroup to add.
-     *
-     * @remarks
-     * This method iterates through each fragment in the provided FragmentsGroup,
-     * and calls the `addMesh` method for each fragment's mesh.
-     *
-     * @example
-     * ```typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * boundingBoxer.add(fragmentsGroup);
-     * ```
-     */
-    add(group: FragmentsGroup): void;
-    /**
-     * Adds a mesh to the BoundingBoxer and calculates the bounding box.
-     *
-     * @param mesh - The mesh to add. It can be an instance of THREE.InstancedMesh, THREE.Mesh, or FRAGS.CurveMesh.
-     * @param itemIDs - An optional iterable of numbers representing the item IDs.
-     *
-     * @remarks
-     * This method calculates the bounding box of the provided mesh and updates the internal minimum and maximum vectors.
-     * If the mesh is an instance of THREE.InstancedMesh, it calculates the bounding box for each instance.
-     * If the mesh is an instance of FRAGS.FragmentMesh and itemIDs are provided, it calculates the bounding box for the specified item IDs.
-     *
-     * @example
-     * ```typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * boundingBoxer.addMesh(mesh);
-     * ```
-     */
-    addMesh(mesh: THREE.InstancedMesh | THREE.Mesh | FRAGS.CurveMesh, itemIDs?: Iterable<number>): void;
-    /**
-     * Uses a FragmentIdMap to add its meshes to the bb calculation.
-     *
-     * This method iterates through the provided `fragmentIdMap`, retrieves the corresponding fragment from the `FragmentsManager`,
-     * and then calls the `addMesh` method for each fragment's mesh, passing the expression IDs as the second parameter.
-     *
-     * @param fragmentIdMap - A mapping of fragment IDs to their corresponding expression IDs.
-     *
-     * @remarks
-     * This method is used to add a mapping of fragment IDs to their corresponding expression IDs.
-     * It ensures that the bounding box calculations are accurate and up-to-date by updating the internal minimum and maximum vectors.
-     *
-     * @example
-     * ```typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * const fragmentIdMap: FRAGS.FragmentIdMap = {
-     *   '5991fa75-2eef-4825-90b3-85177f51a9c9': [123, 245, 389],
-     *   '3469077e-39bf-4fc9-b3e6-4a1d78ad52b0': [454, 587, 612],
-     * };
-     * boundingBoxer.addFragmentIdMap(fragmentIdMap);
-     * ```
-     */
-    addFragmentIdMap(fragmentIdMap: FRAGS.FragmentIdMap): void;
-    private static getFragmentBounds;
-}