@thatopen/components 2.4.10 → 3.1.0

package/dist/core/Viewpoints/src/viewpoint.d.ts

@@ -1,197 +0,0 @@
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { BCFViewpoint, ViewpointOrthographicCamera, ViewpointPerspectiveCamera } from "./types";
-import { CameraProjection } from "../../OrthoPerspectiveCamera";
-import { Components } from "../../Components";
-import { DataMap, DataSet, World } from "../../Types";
-import { SimplePlane } from "../../Clipper";
-/**
- * Represents a BCF compliant viewpoint from BuildingSMART.
- *
- * The Viewpoint class provides methods for managing and interacting with viewpoints.
- * It includes functionality for setting viewpoint properties, updating the camera,
- * applying color to components, and serializing the viewpoint for export.
- */
-export declare class Viewpoint implements BCFViewpoint {
-    title?: string;
-    readonly guid: string;
-    /**
-     * ClippingPlanes can be used to define a subsection of a building model that is related to the topic.
-     * Each clipping plane is defined by Location and Direction.
-     * The Direction vector points in the invisible direction meaning the half-space that is clipped.
-     * @experimental
-     */
-    clippingPlanes: DataSet<SimplePlane>;
-    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
-    /**
-     * A list of components GUIDs to hide when defaultVisibility = true or to show when defaultVisibility = false
-     */
-    readonly exceptionComponents: DataSet<string>;
-    /**
-     * A list of components GUIDs that should be selected (highlighted) when displaying a viewpoint.
-     */
-    readonly selectionComponents: DataSet<string>;
-    /**
-     * A map of colors and components GUIDs that should be colorized when displaying a viewpoint.
-     * For this to work, call viewpoint.colorize()
-     */
-    readonly componentColors: DataMap<THREE.Color, string[]>;
-    /**
-     * Boolean flags to allow fine control over the visibility of spaces.
-     * A typical use of these flags is when DefaultVisibility=true but spaces should remain hidden.
-     * @default false
-     */
-    spacesVisible: boolean;
-    /**
-     * Boolean flags to allow fine control over the visibility of space boundaries.
-     * A typical use of these flags is when DefaultVisibility=true but space boundaries should remain hidden.
-     * @default false
-     */
-    spaceBoundariesVisible: boolean;
-    /**
-     * Boolean flags to allow fine control over the visibility of openings.
-     * A typical use of these flags is when DefaultVisibility=true but openings should remain hidden.
-     * @default false
-     */
-    openingsVisible: boolean;
-    /**
-     * When true, all components should be visible unless listed in the exceptions
-     * When false all components should be invisible unless listed in the exceptions
-     */
-    defaultVisibility: boolean;
-    private get _selectionModelIdMap();
-    private get _exceptionModelIdMap();
-    /**
-     * A list of components that should be selected (highlighted) when displaying a viewpoint.
-     * @returns The fragmentIdMap for components marked as selections.
-     */
-    get selection(): FRAGS.FragmentIdMap;
-    /**
-     * A list of components to hide when defaultVisibility = true or to show when defaultVisibility = false
-     * @returns The fragmentIdMap for components marked as exceptions.
-     */
-    get exception(): FRAGS.FragmentIdMap;
-    /**
-     * Retrieves the projection type of the viewpoint's camera.
-     *
-     * @returns A string representing the projection type of the viewpoint's camera.
-     *          It can be either 'Perspective' or 'Orthographic'.
-     */
-    get projection(): CameraProjection;
-    /**
-     * Retrieves the position vector of the viewpoint's camera.
-     *
-     * @remarks
-     * The position vector represents the camera's position in the world coordinate system.
-     * The function applies the base coordinate system transformation to the position vector.
-     *
-     * @returns A THREE.Vector3 representing the position of the viewpoint's camera.
-     */
-    get position(): THREE.Vector3;
-    /**
-     * Retrieves the direction vector of the viewpoint's camera.
-     *
-     * @remarks
-     * The direction vector represents the direction in which the camera is pointing.
-     * It is calculated by extracting the x, y, and z components from the camera's direction property.
-     *
-     * @returns A THREE.Vector3 representing the direction of the viewpoint's camera.
-     */
-    get direction(): THREE.Vector3;
-    private _components;
-    /**
-     * Represents the world in which the viewpoints are created and managed.
-     */
-    readonly world: World;
-    private get _managerVersion();
-    /**
-     * Retrieves the list of BCF topics associated with the current viewpoint.
-     *
-     * @remarks
-     * This function retrieves the BCFTopics manager from the components,
-     * then filters the list of topics to find those associated with the current viewpoint.
-     *
-     * @returns An array of BCF topics associated with the current viewpoint.
-     */
-    get topics(): import("../../../openbim/BCFTopics").Topic[];
-    constructor(components: Components, world: World, _config?: {
-        data?: Partial<BCFViewpoint>;
-        setCamera?: boolean;
-    });
-    /**
-     * Adds components to the viewpoint based on the provided fragment ID map.
-     *
-     * @param fragmentIdMap - A map containing fragment IDs as keys and arrays of express IDs as values.
-     */
-    addComponentsFromMap(fragmentIdMap: FRAGS.FragmentIdMap): void;
-    /**
-     * Replace the properties of the viewpoint with the provided data.
-     *
-     * @remarks The guid will be ommited as it shouldn't change after it has been initially set.
-     * @remarks The existing selection and exception components will be fully replaced in case new ones are provided.
-     *
-     * @param data - An object containing the properties to be set.
-     *               The properties not included in the object will remain unchanged.
-     *
-     * @returns The viewpoint instance with the updated properties.
-     */
-    set(data: Partial<BCFViewpoint>): this;
-    /**
-     * Sets the viewpoint of the camera in the world.
-     *
-     * @remarks
-     * This function calculates the target position based on the viewpoint information.
-     * It sets the visibility of the viewpoint components and then applies the viewpoint using the camera's controls.
-     *
-     * @param transition - Indicates whether the camera movement should have a transition effect.
-     *                      Default value is `true`.
-     *
-     * @throws An error if the world's camera does not have camera controls.
-     *
-     * @returns A Promise that resolves when the camera has been set.
-     */
-    go(world?: World, transition?: boolean): Promise<void>;
-    /**
-     * Updates the camera settings of the viewpoint based on the current world's camera and renderer.
-     *
-     * @remarks
-     * This function retrieves the camera's position, direction, and aspect ratio from the world's camera and renderer.
-     * It then calculates the camera's perspective or orthographic settings based on the camera type.
-     * Finally, it updates the viewpoint's camera settings and updates the viewpoint to the Viewpoints manager.
-     *
-     * @throws An error if the world's camera does not have camera controls.
-     * @throws An error if the world's renderer is not available.
-     */
-    updateCamera(world?: World): void;
-    applyVisibility(): void;
-    /**
-     * Applies color to the components in the viewpoint based on their GUIDs.
-     *
-     * This function iterates through the `componentColors` map, retrieves the fragment IDs
-     * corresponding to each color, and then uses the `Classifier` to apply the color to those fragments.
-     *
-     * @remarks
-     * The color is applied using the `Classifier.setColor` method, which sets the color of the specified fragments.
-     * The color is provided as a hexadecimal string, prefixed with a '#'.
-     */
-    applyColors(): void;
-    /**
-     * Resets the colors of all components in the viewpoint to their original color.
-     */
-    resetColors(): void;
-    private createComponentTags;
-    private createColorTags;
-    /**
-     * Serializes the viewpoint into a buildingSMART compliant XML string for export.
-     *
-     * @param version - The version of the BCF Manager to use for serialization.
-     *                   If not provided, the current version of the manager will be used.
-     *
-     * @returns A Promise that resolves to an XML string representing the viewpoint.
-     *          The XML string follows the BCF VisualizationInfo schema.
-     *
-     * @throws An error if the world's camera does not have camera controls.
-     * @throws An error if the world's renderer is not available.
-     */
-    serialize(version?: string): Promise<string>;
-}

package/dist/core/Viewpoints/src/viewpoints-config.d.ts

@@ -1,23 +0,0 @@
-import { BooleanSettingsControl } from "../../Types";
-import { Viewpoints } from "../index";
-import { Configurator } from "../../ConfigManager";
-/**
- * Configuration interface for the Viewpoints general behavior.
- */
-export interface ViewpointsConfig {
-    /**
-     * Indicates whether to overwrite the fragments colors when applying viewpoints.
-     * @remarks BCF Viewpoints comes with information to indicate the colors to be applied to components, if any.
-     * @default false
-     */
-    overwriteColors: boolean;
-}
-type ViewpointsConfigType = {
-    overwriteColors: BooleanSettingsControl;
-};
-export declare class ViewpointsConfigManager extends Configurator<Viewpoints, ViewpointsConfigType> {
-    protected _config: ViewpointsConfigType;
-    get overwriteColors(): boolean;
-    set overwriteColors(value: boolean);
-}
-export {};

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";