@thatopen/components 2.0.11 → 2.0.12

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

@@ -3,7 +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. 📕 [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";
@@ -15,21 +15,171 @@ export declare class BoundingBoxer extends Component implements Disposable {
     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;
     private static getFragmentBounds;
 }

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

@@ -1,31 +1,164 @@
 import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
 import { Disposable, Component, Event, Components } from "../../core";
+/**
+ * Interface representing a classification system. The classification is organized by system and class name, and each class contains a map of fragment IDs to their respective express IDs.
+ */
 export interface Classification {
+    /**
+     * A system within the classification.
+     * The key is the system name, and the value is an object representing the classes within the system.
+     */
     [system: string]: {
+        /**
+         * A class within the system.
+         * The key is the class name, and the value is a map of fragment IDs to their respective express IDs.
+         */
         [className: string]: FRAGS.FragmentIdMap;
     };
 }
+/**
+ * The Classifier component is responsible for classifying and categorizing fragments based on various criteria. It provides methods to add, remove, find, and filter fragments based on their classification. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Classifier). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Classifier).
+ */
 export declare class Classifier 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: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
     /** {@link Component.enabled} */
     enabled: boolean;
+    /**
+     * A map representing the classification systems.
+     * The key is the system name, and the value is an object representing the classes within the system.
+     */
     list: Classification;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
     constructor(components: Components);
     private onFragmentsDisposed;
+    /** {@link Disposable.dispose} */
     dispose(): void;
+    /**
+     * Removes a fragment from the classification based on its unique identifier (guid).
+     * This method iterates through all classification systems and classes, and deletes the fragment with the specified guid from the respective group.
+     *
+     * @param guid - The unique identifier of the fragment to be removed.
+     */
     remove(guid: string): void;
+    /**
+     * Finds and returns fragments based on the provided filter criteria.
+     * If no filter is provided, it returns all fragments.
+     *
+     * @param filter - An optional object containing filter criteria.
+     * The keys of the object represent the classification system names,
+     * and the values are arrays of class names to match.
+     *
+     * @returns A map of fragment GUIDs to their respective express IDs,
+     * where the express IDs are filtered based on the provided filter criteria.
+     *
+     * @throws Will throw an error if the fragments map is malformed.
+     */
     find(filter?: {
         [name: string]: string[];
     }): FRAGS.FragmentIdMap;
+    /**
+     * Classifies fragments based on their modelID.
+     *
+     * @param modelID - The unique identifier of the model to classify fragments by.
+     * @param group - The FragmentsGroup containing the fragments to be classified.
+     *
+     * @remarks
+     * This method iterates through the fragments in the provided group,
+     * and classifies them based on their modelID.
+     * The classification is stored in the `list.models` property,
+     * with the modelID as the key and a map of fragment IDs to their respective express IDs as the value.
+     *
+     */
     byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
+    /**
+     * Classifies fragments based on their PredefinedType property.
+     *
+     * @param group - The FragmentsGroup containing the fragments to be classified.
+     *
+     * @remarks
+     * This method iterates through the properties of the fragments in the provided group,
+     * and classifies them based on their PredefinedType property.
+     * The classification is stored in the `list.predefinedTypes` property,
+     * with the PredefinedType as the key and a map of fragment IDs to their respective express IDs as the value.
+     *
+     * @throws Will throw an error if the fragment ID is not found.
+     */
     byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
+    /**
+     * Classifies fragments based on their entity type.
+     *
+     * @param group - The FragmentsGroup containing the fragments to be classified.
+     *
+     * @remarks
+     * This method iterates through the relations of the fragments in the provided group,
+     * and classifies them based on their entity type.
+     * The classification is stored in the `list.entities` property,
+     * with the entity type as the key and a map of fragment IDs to their respective express IDs as the value.
+     *
+     * @throws Will throw an error if the fragment ID is not found.
+     */
     byEntity(group: FRAGS.FragmentsGroup): void;
+    /**
+     * Classifies fragments based on a specific IFC relationship.
+     *
+     * @param group - The FragmentsGroup containing the fragments to be classified.
+     * @param ifcRel - The IFC relationship number to classify fragments by.
+     * @param systemName - The name of the classification system to store the classification.
+     *
+     * @remarks
+     * This method iterates through the relations of the fragments in the provided group,
+     * and classifies them based on the specified IFC relationship.
+     * The classification is stored in the `list` property under the specified system name,
+     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
+     *
+     * @throws Will throw an error if the fragment ID is not found or if the IFC relationship is not valid.
+     */
     byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
+    /**
+     * Classifies fragments based on their spatial structure in the IFC model.
+     *
+     * @param model - The FragmentsGroup containing the fragments to be classified.
+     *
+     * @remarks
+     * This method iterates through the relations of the fragments in the provided group,
+     * and classifies them based on their spatial structure in the IFC model.
+     * The classification is stored in the `list` property under the system name "spatialStructures",
+     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
+     *
+     * @throws Will throw an error if the fragment ID is not found or if the model relations do not exist.
+     */
     bySpatialStructure(model: FRAGS.FragmentsGroup): Promise<void>;
+    /**
+     * Sets the color of the specified fragments.
+     *
+     * @param items - A map of fragment IDs to their respective express IDs.
+     * @param color - The color to set for the fragments.
+     * @param override - A boolean indicating whether to override the existing color of the fragments.
+     *
+     * @remarks
+     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
+     * and sets their color using the `setColor` method of the FragmentsGroup class.
+     *
+     * @throws Will throw an error if the fragment with the specified ID is not found.
+     */
     setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
+    /**
+     * Resets the color of the specified fragments to their original color.
+     *
+     * @param items - A map of fragment IDs to their respective express IDs.
+     *
+     * @remarks
+     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
+     * and resets their color using the `resetColor` method of the FragmentsGroup class.
+     *
+     * @throws Will throw an error if the fragment with the specified ID is not found.
+     */
     resetColor(items: FRAGS.FragmentIdMap): void;
     protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number): void;
 }

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

@@ -1,13 +1,50 @@
 import { Component, Disposable, Event, Components } from "../../core";
+/**
+ * The Exploder component is responsible for managing the explosion of 3D model fragments (generally by floor). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Exploder). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Exploder).
+ */
 export declare class Exploder 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: "d260618b-ce88-4c7d-826c-6debb91de3e2";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Component.enabled} */
     enabled: boolean;
+    /**
+     * The height of the explosion animation.
+     * This property determines the vertical distance by which fragments are moved during the explosion.
+     * Default value is 10.
+     */
     height: number;
+    /**
+     * The group name used for the explosion animation.
+     * This property specifies the group of fragments that will be affected by the explosion.
+     * Default value is "storeys".
+     */
     groupName: string;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+    /**
+     * A set of strings representing the exploded items.
+     * This set is used to keep track of which items have been exploded.
+     */
     list: Set<string>;
     constructor(components: Components);
+    /** {@link Disposable.dispose} */
     dispose(): void;
+    /**
+     * Sets the explosion state of the fragments.
+     *
+     * @param active - A boolean indicating whether to activate or deactivate the explosion.
+     *
+     * @remarks
+     * This method applies a vertical transformation to the fragments based on the `active` parameter.
+     * If `active` is true, the fragments are moved upwards by a distance determined by the `height` property.
+     * If `active` is false, the fragments are moved back to their original position.
+     *
+     * The method also keeps track of the exploded items using the `list` set.
+     *
+     * @throws Will throw an error if the `Classifier` or `FragmentsManager` components are not found in the `components` system.
+     */
     set(active: boolean): void;
 }

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

@@ -4,32 +4,60 @@ 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).
+ * Component to load, delete and manage [fragments](https://github.com/ThatOpen/engine_fragment) efficiently. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/FragmentsManager). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/FragmentsManager).
  */
 export declare class FragmentsManager 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: "fef46874-46a3-461b-8c44-2922ab77c806";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
+    /**
+     * Event triggered when fragments are loaded.
+     */
     readonly onFragmentsLoaded: Event<FragmentsGroup>;
+    /**
+     * Event triggered when fragments are disposed.
+     */
     readonly onFragmentsDisposed: Event<{
         groupID: string;
         fragmentIDs: string[];
     }>;
-    /** All the created [fragments](https://github.com/ThatOpen/engine_fragment). */
+    /**
+     * Map containing all loaded fragments.
+     * The key is the fragment's unique identifier, and the value is the fragment itself.
+     */
     readonly list: Map<string, Fragment>;
+    /**
+     * Map containing all loaded fragment groups.
+     * The key is the group's unique identifier, and the value is the group itself.
+     */
     readonly groups: Map<string, FragmentsGroup>;
+    baseCoordinationModel: string;
     /** {@link Component.enabled} */
     enabled: boolean;
-    baseCoordinationModel: string;
     private _loader;
-    /** The list of meshes of the created fragments. */
+    /**
+     * Getter for the meshes of all fragments in the FragmentsManager.
+     * It iterates over the fragments in the list and pushes their meshes into an array.
+     * @returns {THREE.Mesh[]} An array of THREE.Mesh objects representing the fragments.
+     */
     get meshes(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[];
     constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
+    /**
+     * Dispose of a specific fragment group.
+     * This method removes the group from the groups map, deletes all fragments within the group from the list,
+     * disposes of the group, and triggers the onFragmentsDisposed event.
+     *
+     * @param group - The fragment group to be disposed.
+     */
     disposeGroup(group: FragmentsGroup): void;
     /**
-     * Loads a binar file that contain fragment geometry.
+     * Loads a binary file that contain fragment geometry.
      * @param data - The binary data to load.
      * @param config - Optional configuration for loading.
      * @param config.coordinate - Whether to apply coordinate transformation. Default is true.
@@ -43,7 +71,7 @@ export declare class FragmentsManager extends Component implements Disposable {
         relationsMap: RelationsMap;
     }>): FragmentsGroup;
     /**
-     * Export the specified fragments.
+     * Export the specified fragmentsgroup to binary data.
      * @param group - the fragments group to be exported.
      * @returns the exported data as binary buffer.
      */
@@ -69,5 +97,16 @@ export declare class FragmentsManager extends Component implements Disposable {
     modelIdToFragmentIdMap(modelIdMap: {
         [modelID: string]: Set<number>;
     }): FRAGS.FragmentIdMap;
+    /**
+     * Applies coordinate transformation to the provided models.
+     * If no models are provided, all groups are used.
+     * The first model in the list becomes the base model for coordinate transformation.
+     * All other models are then transformed to match the base model's coordinate system.
+     *
+     * @param models - The models to apply coordinate transformation to.
+     * If not provided, all groups are used.
+     *
+     * @returns {void}
+     */
     coordinate(models?: FragmentsGroup[]): void;
 }

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

@@ -1,10 +1,38 @@
 import * as FRAGS from "@thatopen/fragments";
 import { Components, Component } from "../../core";
+/**
+ * A component that hides or isolates fragments within a 3D scene. It extends the base Component class and provides methods to control fragment visibility and isolation. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Hider). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Hider).
+ */
 export declare class Hider extends Component {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
     static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+    /** {@link Component.enabled} */
     enabled: boolean;
     constructor(components: Components);
+    /**
+     * Sets the visibility of fragments within the 3D scene.
+     * If no `items` parameter is provided, all fragments will be set to the specified visibility.
+     * If `items` is provided, only the specified fragments will be affected.
+     *
+     * @param visible - The visibility state to set for the fragments.
+     * @param items - An optional map of fragment IDs and their corresponding sub-fragment IDs to be affected.
+     * If not provided, all fragments will be affected.
+     *
+     * @returns {void}
+     */
     set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
+    /**
+     * Isolates fragments within the 3D scene by hiding all other fragments and showing only the specified ones.
+     * It calls the `set` method twice: first to hide all fragments, and then to show only the specified ones.
+     *
+     * @param items - A map of fragment IDs and their corresponding sub-fragment IDs to be isolated.
+     * If not provided, all fragments will be isolated.
+     *
+     * @returns {void}
+     */
     isolate(items: FRAGS.FragmentIdMap): void;
     private updateCulledVisibility;
 }

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

@@ -2,19 +2,49 @@ import * as WEBIFC from "web-ifc";
 import { Components, Disposable, Event, Component } from "../../core";
 import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
 export * from "./src";
+/**
+ * A component that handles the tiling of IFC geometries for efficient streaming. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcGeometryTiler). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcGeometryTiler).
+ */
 export declare class IfcGeometryTiler 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: "d9999a00-e1f5-4d3f-8cfe-c56e08609764";
-    onGeometryStreamed: Event<{
+    /**
+     * Event triggered when geometry is streamed.
+     * Contains the streamed geometry data and its buffer.
+     */
+    readonly onGeometryStreamed: Event<{
         buffer: Uint8Array;
         data: StreamedGeometries;
     }>;
-    onAssetStreamed: Event<StreamedAsset[]>;
-    onProgress: Event<number>;
-    onIfcLoaded: Event<Uint8Array>;
+    /**
+     * Event triggered when assets are streamed.
+     * Contains the streamed assets.
+     */
+    readonly onAssetStreamed: Event<StreamedAsset[]>;
+    /**
+     * Event triggered to indicate the progress of the streaming process.
+     * Contains the progress percentage.
+     */
+    readonly onProgress: Event<number>;
+    /**
+     * Event triggered when the IFC file is loaded.
+     * Contains the loaded IFC file data.
+     */
+    readonly onIfcLoaded: Event<Uint8Array>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
+    /**
+     * Settings for the IfcGeometryTiler.
+     */
     settings: IfcStreamingSettings;
+    /** {@link Component.enabled} */
     enabled: boolean;
+    /**
+     * The WebIFC API instance used for IFC file processing.
+     */
     webIfc: WEBIFC.IfcAPI;
     private _spatialTree;
     private _metaData;
@@ -27,8 +57,36 @@ export declare class IfcGeometryTiler extends Component implements Disposable {
     private _assets;
     private _meshesWithHoles;
     constructor(components: Components);
+    /** {@link Disposable.dispose} */
     dispose(): void;
+    /**
+     * This method streams the IFC file from a given buffer.
+     *
+     * @param data - The Uint8Array containing the IFC file data.
+     * @returns A Promise that resolves when the streaming process is complete.
+     *
+     * @remarks
+     * This method cleans up any resources after the streaming process is complete.
+     *
+     * @example
+     * ```typescript
+     * const ifcData = await fetch('path/to/ifc/file.ifc');
+     * const rawBuffer = await response.arrayBuffer();
+     * const ifcBuffer = new Uint8Array(rawBuffer);
+     * await ifcGeometryTiler.streamFromBuffer(ifcBuffer);
+     * ```
+     */
     streamFromBuffer(data: Uint8Array): Promise<void>;
+    /**
+     * This method streams the IFC file from a given callback.
+     *
+     * @param loadCallback - The callback function that will be used to load the IFC file.
+     * @returns A Promise that resolves when the streaming process is complete.
+     *
+     * @remarks
+     * This method cleans up any resources after the streaming process is complete.
+     *
+     */
     streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
     private readIfcFile;
     private streamIfcFile;

package/dist/fragments/IfcGeometryTiler/src/base-types.d.ts

@@ -1,15 +1,29 @@
+/**
+ * A dictionary of geometries streamed from a server. Each geometry is identified by a unique number (id), and contains information about its bounding box, whether it has holes, and an optional file path for the geometry data.
+ */
 export interface StreamedGeometries {
     [id: number]: {
+        /** The bounding box of the geometry as a Float32Array. */
         boundingBox: Float32Array;
+        /** A boolean indicating whether the geometry has holes. */
         hasHoles: boolean;
+        /** An optional file path for the geometry data. */
         geometryFile?: string;
     };
 }
+/**
+ * A streamed asset, which consists of multiple geometries. Each geometry in the asset is identified by a unique number (geometryID), and contains information about its transformation and color.
+ */
 export interface StreamedAsset {
+    /** The unique identifier of the asset. */
     id: number;
+    /** An array of geometries associated with the asset. */
     geometries: {
+        /** The unique identifier of the geometry. */
         geometryID: number;
+        /** The transformation matrix of the geometry as a number array. */
         transformation: number[];
+        /** The color of the geometry as a number array. */
         color: number[];
     }[];
 }

package/dist/fragments/IfcGeometryTiler/src/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./streaming-settings";
-export * from "./fragment-props-stream-converter";
 export * from "./base-types";