@thatopen/components 2.3.0-alpha.9 → 2.3.0

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

@@ -6,7 +6,7 @@ export declare class Components implements Disposable {
     /**
      * The version of the @thatopen/components library.
      */
-    static readonly release = "2.3.0-alpha.1";
+    static readonly release = "2.3.0";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<void>;
     /**
@@ -20,6 +20,25 @@ export declare class Components implements Disposable {
      */
     enabled: boolean;
     private _clock;
+    /**
+     * Event that triggers the Components instance is initialized.
+     *
+     * @remarks
+     * This event is triggered once when the {@link Components.init} method has been called and finish processing.
+     * This is useful to set configuration placeholders that need to be executed when the components instance is initialized.
+     * For example, enabling and configuring custom effects in a post-production renderer.
+     *
+     * @example
+     * ```typescript
+     * const components = new Components();
+     * components.onInit.add(() => {
+     *   // Enable custom effects in the post-production renderer
+     *   // or any other operation dependant on the component initialization
+     * });
+     * components.init();
+     * ```
+     */
+    readonly onInit: Event<undefined>;
     /**
      * Adds a component to the list of components.
      * Throws an error if a component with the same UUID already exists.
@@ -51,8 +70,6 @@ export declare class Components implements Disposable {
      * Initializes the Components instance.
      * This method starts the animation loop, sets the enabled flag to true,
      * and calls the update method.
-     *
-     * @returns {void}
      */
     init(): void;
     /**

package/dist/core/Grids/src/simple-grid-config.d.ts

@@ -13,6 +13,10 @@ type SimpleGridConfigType = {
  * Configuration interface for the {@link SimpleGrid}.
  */
 export interface SimpleGridConfig {
+    /**
+     * Whether the grid is visible or not.
+     */
+    visible: boolean;
     /**
      * The color of the grid lines.
      */
@@ -32,15 +36,45 @@ export interface SimpleGridConfig {
 }
 export declare class SimpleGridConfigManager extends Configurator<SimpleGrid, SimpleGridConfigType> {
     protected _config: SimpleGridConfigType;
+    /**
+     * Whether the grid is visible or not.
+     */
     get visible(): boolean;
+    /**
+     * Whether the grid is visible or not.
+     */
     set visible(value: boolean);
+    /**
+     * The color of the grid lines.
+     */
     get color(): THREE.Color;
+    /**
+     * The color of the grid lines.
+     */
     set color(value: THREE.Color);
+    /**
+     * The size of the primary grid lines.
+     */
     get primarySize(): number;
+    /**
+     * The size of the primary grid lines.
+     */
     set primarySize(value: number);
+    /**
+     * The size of the secondary grid lines.
+     */
     get secondarySize(): number;
+    /**
+     * The size of the secondary grid lines.
+     */
     set secondarySize(value: number);
+    /**
+     * The distance at which the grid lines start to fade away.
+     */
     get distance(): number;
+    /**
+     * The distance at which the grid lines start to fade away.
+     */
     set distance(value: number);
 }
 export {};

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

@@ -17,6 +17,8 @@ export declare class MiniMaps extends Component implements Updateable, Disposabl
     readonly onBeforeUpdate: Event<unknown>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<unknown>;
     /** {@link Component.enabled} */
     enabled: boolean;
     /**

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

@@ -1,89 +1,2 @@
-import * as THREE from "three";
-import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
-/**
- * A class representing a 2D minimap of a 3D world.
- */
-export declare class MiniMap implements Resizeable, Updateable, Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Resizeable.onResize} */
-    readonly onResize: Event<THREE.Vector2>;
-    /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
-     */
-    frontOffset: number;
-    /**
-     * The override material for the minimap.
-     * It is used to render the depth information of the world onto the minimap.
-     */
-    overrideMaterial: THREE.MeshDepthMaterial;
-    /**
-     * The background color of the minimap.
-     * It is used to set the background color of the minimap's renderer.
-     */
-    backgroundColor: THREE.Color;
-    /**
-     * The WebGL renderer for the minimap.
-     * It is used to render the minimap onto the screen.
-     */
-    renderer: THREE.WebGLRenderer;
-    /**
-     * A flag indicating whether the minimap is enabled.
-     * If disabled, the minimap will not update or render.
-     */
-    enabled: boolean;
-    /**
-     * The world in which the minimap is displayed.
-     * It provides access to the 3D scene, camera, and other relevant world elements.
-     */
-    world: World;
-    private _lockRotation;
-    private _camera;
-    private _plane;
-    private _size;
-    private _tempVector1;
-    private _tempVector2;
-    private _tempTarget;
-    private readonly down;
-    /**
-     * Gets or sets whether the minimap rotation is locked.
-     * When rotation is locked, the minimap will always face the same direction as the camera.
-     */
-    get lockRotation(): boolean;
-    /**
-     * Sets whether the minimap rotation is locked.
-     * When rotation is locked, the minimap will always face the same direction as the camera.
-     * @param active - If `true`, rotation is locked. If `false`, rotation is not locked.
-     */
-    set lockRotation(active: boolean);
-    /**
-     * Gets the current zoom level of the minimap.
-     * The zoom level determines how much of the world is visible on the minimap.
-     * @returns The current zoom level of the minimap.
-     */
-    get zoom(): number;
-    /**
-     * Sets the zoom level of the minimap.
-     * The zoom level determines how much of the world is visible on the minimap.
-     * @param value - The new zoom level of the minimap.
-     */
-    set zoom(value: number);
-    constructor(world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** Returns the camera used by the MiniMap */
-    get(): THREE.OrthographicCamera;
-    /** {@link Updateable.update} */
-    update(): void;
-    /** {@link Resizeable.getSize} */
-    getSize(): THREE.Vector2;
-    /** {@link Resizeable.resize} */
-    resize(size?: THREE.Vector2): void;
-    private updatePlanes;
-}
+export * from "./mini-map";
+export * from "./mini-map-config";

package/dist/core/MiniMap/src/mini-map-config.d.ts

@@ -0,0 +1,112 @@
+import * as THREE from "three";
+import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
+import { Configurator } from "../../ConfigManager";
+import { MiniMap } from "./index";
+type MiniMapConfigType = {
+    visible: BooleanSettingsControl;
+    lockRotation: BooleanSettingsControl;
+    zoom: NumberSettingControl;
+    frontOffset: NumberSettingControl;
+    sizeX: NumberSettingControl;
+    sizeY: NumberSettingControl;
+    backgroundColor: ColorSettingsControl;
+};
+/**
+ * Configuration interface for the {@link MiniMap}.
+ */
+export interface MiniMapConfig {
+    /**
+     * Whether the minimap is visible or not.
+     */
+    visible: boolean;
+    /**
+     * Whether to lock the rotation of the top camera in the minimap.
+     */
+    lockRotation: boolean;
+    /**
+     * The zoom of the camera in the minimap.
+     */
+    zoom: number;
+    /**
+     * The front offset of the minimap.
+     * It determines how much the minimap's view is offset from the camera's view.
+     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
+     */
+    frontOffset: number;
+    /**
+     * The horizontal dimension of the minimap.
+     */
+    sizeX: number;
+    /**
+     * The vertical dimension of the minimap.
+     */
+    sizeY: number;
+    /**
+     * The color of the background of the minimap.
+     */
+    backgroundColor: THREE.Color;
+}
+export declare class MiniMapConfigManager extends Configurator<MiniMap, MiniMapConfigType> {
+    protected _config: MiniMapConfigType;
+    /**
+     * Whether the minimap is visible or not.
+     */
+    get visible(): boolean;
+    /**
+     * Whether the minimap is visible or not.
+     */
+    set visible(value: boolean);
+    /**
+     * Whether to lock the rotation of the top camera in the minimap.
+     */
+    get lockRotation(): boolean;
+    /**
+     * Whether to lock the rotation of the top camera in the minimap.
+     */
+    set lockRotation(value: boolean);
+    /**
+     * The zoom of the camera in the minimap.
+     */
+    get zoom(): number;
+    /**
+     * The zoom of the camera in the minimap.
+     */
+    set zoom(value: number);
+    /**
+     * The front offset of the minimap.
+     * It determines how much the minimap's view is offset from the camera's view.
+     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
+     */
+    get frontOffset(): number;
+    /**
+     * The front offset of the minimap.
+     * It determines how much the minimap's view is offset from the camera's view.
+     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
+     */
+    set frontOffset(value: number);
+    /**
+     * The horizontal dimension of the minimap.
+     */
+    get sizeX(): number;
+    /**
+     * The horizontal dimension of the minimap.
+     */
+    set sizeX(value: number);
+    /**
+     * The vertical dimension of the minimap.
+     */
+    get sizeY(): number;
+    /**
+     * The vertical dimension of the minimap.
+     */
+    set sizeY(value: number);
+    /**
+     * The color of the background of the minimap.
+     */
+    get backgroundColor(): THREE.Color;
+    /**
+     * The color of the background of the minimap.
+     */
+    set backgroundColor(value: THREE.Color);
+}
+export {};

package/dist/core/MiniMap/src/mini-map.d.ts

@@ -0,0 +1,100 @@
+import * as THREE from "three";
+import { Resizeable, Updateable, World, Event, Disposable, Configurable } from "../../Types";
+import { MiniMapConfig, MiniMapConfigManager } from "./mini-map-config";
+import { Components } from "../../Components";
+/**
+ * A class representing a 2D minimap of a 3D world.
+ */
+export declare class MiniMap implements Resizeable, Updateable, Disposable, Configurable<MiniMapConfigManager, MiniMapConfig> {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Resizeable.onResize} */
+    readonly onResize: Event<THREE.Vector2>;
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<unknown>;
+    /**
+     * The front offset of the minimap.
+     * It determines how much the minimap's view is offset from the camera's view.
+     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
+     */
+    frontOffset: number;
+    /**
+     * The override material for the minimap.
+     * It is used to render the depth information of the world onto the minimap.
+     */
+    overrideMaterial: THREE.MeshDepthMaterial;
+    /**
+     * The background color of the minimap.
+     * It is used to set the background color of the minimap's renderer.
+     */
+    backgroundColor: THREE.Color;
+    /**
+     * The WebGL renderer for the minimap.
+     * It is used to render the minimap onto the screen.
+     */
+    renderer: THREE.WebGLRenderer;
+    /**
+     * A flag indicating whether the minimap is enabled.
+     * If disabled, the minimap will not update or render.
+     */
+    enabled: boolean;
+    /**
+     * The world in which the minimap is displayed.
+     * It provides access to the 3D scene, camera, and other relevant world elements.
+     */
+    world: World;
+    /** {@link Configurable.config} */
+    config: MiniMapConfigManager;
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
+    protected _defaultConfig: MiniMapConfig;
+    private _lockRotation;
+    private _size;
+    private _camera;
+    private _plane;
+    private _tempVector1;
+    private _tempVector2;
+    private _tempTarget;
+    private readonly down;
+    /**
+     * Gets or sets whether the minimap rotation is locked.
+     * When rotation is locked, the minimap will always face the same direction as the camera.
+     */
+    get lockRotation(): boolean;
+    /**
+     * Sets whether the minimap rotation is locked.
+     * When rotation is locked, the minimap will always face the same direction as the camera.
+     * @param active - If `true`, rotation is locked. If `false`, rotation is not locked.
+     */
+    set lockRotation(active: boolean);
+    /**
+     * Gets the current zoom level of the minimap.
+     * The zoom level determines how much of the world is visible on the minimap.
+     * @returns The current zoom level of the minimap.
+     */
+    get zoom(): number;
+    /**
+     * Sets the zoom level of the minimap.
+     * The zoom level determines how much of the world is visible on the minimap.
+     * @param value - The new zoom level of the minimap.
+     */
+    set zoom(value: number);
+    constructor(world: World, components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** Returns the camera used by the MiniMap */
+    get(): THREE.OrthographicCamera;
+    /** {@link Updateable.update} */
+    update(): void;
+    /** {@link Resizeable.getSize} */
+    getSize(): THREE.Vector2;
+    /** {@link Resizeable.resize} */
+    resize(size?: THREE.Vector2): void;
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<MiniMapConfig>): void;
+    private updatePlanes;
+}

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

@@ -25,6 +25,7 @@ export declare class Viewpoints extends Component implements Disposable, Configu
     setup(): void;
     onSetup: Event<unknown>;
     config: ViewpointsConfigManager;
+    /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
     /**
      * Disposes of the Viewpoints component and its associated resources.

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

@@ -19,6 +19,9 @@ export interface ViewpointPerspectiveCamera extends ViewpointCamera {
 export interface ViewpointOrthographicCamera extends ViewpointCamera {
     viewToWorldScale: number;
 }
+/**
+ * Represents a viewpoint in a BCF file.
+ */
 export interface BCFViewpoint {
     title?: string;
     guid: string;

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

@@ -5,13 +5,21 @@ 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;
-    guid: 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;
@@ -114,14 +122,13 @@ export declare class Viewpoint implements BCFViewpoint {
      * 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.
-     *
-     * @returns A Promise that resolves when the components have been added to the viewpoint.
      */
-    addComponentsFromMap(fragmentIdMap: FRAGS.FragmentIdMap): Promise<void>;
+    addComponentsFromMap(fragmentIdMap: FRAGS.FragmentIdMap): void;
     /**
-     * Sets the properties of the viewpoint with the provided data.
+     * 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.

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

@@ -1,4 +1,4 @@
-import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer } from "../Types";
+import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer, DataMap } from "../Types";
 import { Components } from "../Components";
 import { SimpleWorld } from "./src";
 export * from "./src";
@@ -17,21 +17,11 @@ export declare class Worlds extends Component implements Updateable, Disposable
     readonly onBeforeUpdate: Event<unknown>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
-    /**
-     * An event that is triggered when a new world is created.
-     * The event passes the newly created world as a parameter.
-     */
-    readonly onWorldCreated: Event<World>;
-    /**
-     * An event that is triggered when a world is deleted.
-     * The event passes the UUID of the deleted world as a parameter.
-     */
-    readonly onWorldDeleted: Event<string>;
     /**
      * A collection of worlds managed by this component.
      * The key is the unique identifier (UUID) of the world, and the value is the World instance.
      */
-    list: Map<string, World>;
+    list: DataMap<string, World>;
     /** {@link Component.enabled} */
     enabled: boolean;
     constructor(components: Components);
@@ -51,16 +41,12 @@ export declare class Worlds extends Component implements Updateable, Disposable
      * @param {World} world - The world to be deleted.
      *
      * @throws {Error} - Throws an error if the provided world is not found in the list.
-     *
-     * @returns {void}
      */
     delete(world: World): void;
     /**
      * Disposes of the Worlds component and all its managed worlds.
      * This method sets the enabled flag to false, disposes of all worlds, clears the list,
      * and triggers the onDisposed event.
-     *
-     * @returns {void}
      */
     dispose(): void;
     /** {@link Updateable.update} */

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

@@ -28,9 +28,9 @@ export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends Base
      */
     enabled: boolean;
     /**
-     * A unique identifier for the world.
+     * A unique identifier for the world. Is not meant to be changed at any moment.
      */
-    uuid: string;
+    readonly uuid: string;
     /**
      * An optional name for the world.
      */

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

@@ -14,7 +14,7 @@ export interface Classification {
          * A class within the system.
          * The key is the class name, and the value is an object containing a map of fragment IDs with extra information.
          */
-        [className: string]: {
+        [groupName: string]: {
             map: FRAGS.FragmentIdMap;
             name: string;
             id: number | null;

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

@@ -108,6 +108,14 @@ export declare class FragmentsManager extends Component implements Disposable {
      * @returns A fragment ID map, where the keys are fragment IDs and the values are the corresponding express IDs.
      */
     guidToFragmentIdMap(guids: Iterable<string>): FRAGS.FragmentIdMap;
+    /**
+     * Converts a fragment ID map to a collection of IFC GUIDs.
+     *
+     * @param fragmentIdMap - A fragment ID map to be converted to a collection of IFC GUIDs.
+     *
+     * @returns An array of IFC GUIDs.
+     */
+    fragmentIdMapToGuids(fragmentIdMap: FRAGS.FragmentIdMap): string[];
     /**
      * Applies coordinate transformation to the provided models.
      * If no models are provided, all groups are used.

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

@@ -76,7 +76,7 @@ export declare class IfcLoader extends Component implements Disposable {
      * const group = await ifcLoader.load(ifcData);
      * ```
      */
-    load(data: Uint8Array, coordinate?: boolean): Promise<FRAGS.FragmentsGroup>;
+    load(data: Uint8Array, coordinate?: boolean, name?: string): Promise<FRAGS.FragmentsGroup>;
     /**
      * Reads an IFC file and initializes the Web-IFC library.
      *

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

@@ -0,0 +1,50 @@
+import { Component, Components } from "../../core";
+import { IfcQueryGroup } from "./src/ifc-query-group";
+import { IfcFinderQuery } from "./src";
+export * from "./src";
+/**
+ * Component to make text queries in the IFC.
+ */
+export declare class IfcFinder extends Component {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "0da7ad77-f734-42ca-942f-a074adfd1e3a";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * List of all created {@link IfcQueryGroup} instances.
+     */
+    list: Map<string, IfcQueryGroup>;
+    /**
+     * List of all queries from all created {@link IfcQueryGroup} instances.
+     */
+    get queries(): Set<IfcFinderQuery>;
+    constructor(components: Components);
+    /**
+     * Imports all the query groups provided in the given data. You can generate this data to save the result of queries and persist it over time.
+     * @param data The data containing the serialized query groups to import.
+     */
+    import(data: {
+        [groupID: string]: any;
+    }): void;
+    /**
+     * Exports all the query groups created. You can then import this data back using the import method.
+     */
+    export(): {
+        [groupID: string]: any;
+    };
+    /**
+     * Creates a new {@link IfcQueryGroup}.
+     */
+    create(): IfcQueryGroup;
+    /**
+     * Creates the {@link IfcQueryGroup} with the given ID.
+     */
+    delete(id: string): void;
+    /**
+     * Deletes all {@link IfcQueryGroup} instances.
+     */
+    clear(): void;
+}

package/dist/ifc/IfcFinder/src/ifc-basic-query.d.ts

@@ -0,0 +1,35 @@
+import * as FRAGS from "@thatopen/fragments";
+import { IfcFinderRule, SerializedQuery } from "./types";
+import { IfcFinderQuery } from "./ifc-finder-query";
+import { Components } from "../../../core";
+/**
+ * A query that checks the direct attributes of IFC items.
+ */
+export declare class IfcBasicQuery extends IfcFinderQuery {
+    /**
+     * {@link IfcFinderQuery.name}
+     */
+    name: string;
+    /**
+     * The type of this query.
+     */
+    static type: "IfcBasicQuery";
+    /**
+     * {@link IfcFinderQuery.items}
+     */
+    get items(): FRAGS.FragmentIdMap;
+    constructor(components: Components, data: {
+        name: string;
+        rules: IfcFinderRule[];
+        inclusive: boolean;
+    });
+    /**
+     * {@link IfcFinderQuery.export}
+     */
+    export(): SerializedQuery;
+    /**
+     * {@link IfcFinderQuery.update}
+     */
+    update(modelID: string, file: File): Promise<void>;
+    protected findInLines(modelID: string, lines: string[]): void;
+}