@thatopen/components 2.0.8 → 2.0.10

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

@@ -2,19 +2,34 @@ 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).
+ * 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. */
+    /**
+     * 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;
@@ -24,6 +39,13 @@ export declare class SimpleRenderer extends BaseRenderer {
     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;

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

@@ -1,6 +1,9 @@
 import * as THREE from "three";
 import { BaseScene, Configurable, Event } from "../../Types";
 import { Components } from "../../Components";
+/**
+ * Configuration interface for the {@link SimpleScene}. Defines properties for directional and ambient lights.
+ */
 export interface SimpleSceneConfig {
     directionalLight: {
         color: THREE.Color;
@@ -13,18 +16,24 @@ export interface SimpleSceneConfig {
     };
 }
 /**
- * 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.
- * @noInheritDoc
+ * 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<{}> {
     /** {@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.onSetup} */
     readonly onSetup: Event<SimpleScene>;
+    /**
+   * Configuration interface for the {@link SimpleScene}.
+   * Defines properties for directional and ambient lights.
+   */
     config: Required<SimpleSceneConfig>;
     constructor(components: Components);
-    /** Creates a simple and nice default set up for the scene (e.g. lighting). */
+    /** {@link Configurable.setup} */
     setup(config?: Partial<SimpleSceneConfig>): void;
 }

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

@@ -1,28 +1,79 @@
 import * as THREE from "three";
-import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer } from "../../Types";
-import { Components } from "../../Components";
-export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World {
+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).
+     * 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.
+     */
     uuid: string;
+    /**
+     * An optional name for the world.
+     */
     name?: string;
-    readonly onDisposed: Event<unknown>;
     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);
-    constructor(components: Components);
+    /** {@link Updateable.update} */
     update(delta?: number): void;
+    /** {@link Disposable.dispose} */
     dispose(disposeResources?: boolean): void;
 }

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

@@ -3,8 +3,7 @@ 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.
+ * 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.
  */
 export declare class BoundingBoxer extends Component implements Disposable {
     static readonly uuid: "d1444724-dba6-4cdd-a0c7-68ee1450d166";

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

@@ -4,8 +4,7 @@ import * as FRAGS from "@thatopen/fragments";
 import { Component, Components, Event, Disposable } from "../../core";
 import { RelationsMap } from "../../ifc/IfcRelationsIndexer/src/types";
 /**
- * Object that can efficiently load binary files that contain
- * [fragment geometry](https://github.com/ThatOpen/engine_fragment).
+ * Object that can efficiently load binary files that contain [fragment geometry](https://github.com/ThatOpen/engine_fragment).
  */
 export declare class FragmentsManager extends Component implements Disposable {
     static readonly uuid: "fef46874-46a3-461b-8c44-2922ab77c806";
@@ -49,5 +48,26 @@ export declare class FragmentsManager extends Component implements Disposable {
      * @returns the exported data as binary buffer.
      */
     export(group: FragmentsGroup): Uint8Array;
+    /**
+     * Gets a map of model IDs to sets of express IDs for the given fragment ID map.
+     * @param fragmentIdMap - A map of fragment IDs to their corresponding express IDs.
+     * @returns A map of model IDs to sets of express IDs.
+     */
+    getModelIdMap(fragmentIdMap: FRAGS.FragmentIdMap): {
+        [modelID: string]: Set<number>;
+    };
+    /**
+     * Converts a map of model IDs to sets of express IDs to a fragment ID map.
+     * @param modelIdMap - A map of model IDs to their corresponding express IDs.
+     * @returns A fragment ID map.
+     * @remarks
+     * This method iterates through the provided model ID map, retrieves the corresponding model from the `groups` map,
+     * and then calls the `getFragmentMap` method of the model to obtain a fragment ID map for the given express IDs.
+     * The fragment ID maps are then merged into a single map and returned.
+     * If a model with a given ID is not found in the `groups` map, the method skips that model and continues with the next one.
+     */
+    modelIdToFragmentIdMap(modelIdMap: {
+        [modelID: string]: Set<number>;
+    }): FRAGS.FragmentIdMap;
     coordinate(models?: FragmentsGroup[]): void;
 }

package/dist/ifc/IfcRelationsIndexer/index.d.ts

@@ -3,8 +3,7 @@ import { FragmentsGroup } from "@thatopen/fragments";
 import { Disposable, Event, Component, Components } from "../../core";
 import { RelationsMap, ModelsRelationMap, InverseAttribute } from "./src/types";
 /**
- * Indexer for IFC entities, facilitating the indexing and retrieval of IFC entity relationships.
- * It is designed to process models properties by indexing their IFC entities' relations based on predefined inverse attributes, and provides methods to query these relations.
+ * Indexer for IFC entities, facilitating the indexing and retrieval of IFC entity relationships. It is designed to process models properties by indexing their IFC entities' relations based on predefined inverse attributes, and provides methods to query these relations.
  */
 export declare class IfcRelationsIndexer extends Component implements Disposable {
     static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
@@ -29,6 +28,7 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
     readonly relationMaps: ModelsRelationMap;
     constructor(components: Components);
     private onFragmentsDisposed;
+    private indexRelations;
     /**
      * Adds a relation map to the model's relations map.
      *