@thatopen/components 2.4.11 → 3.1.1

package/dist/core/Types/src/data-map.d.ts

@@ -1,73 +0,0 @@
-import { Event } from "./event";
-/**
- * A class that extends the built-in Map class and provides additional events for item set, update, delete, and clear operations.
- *
- * @template K - The type of keys in the map.
- * @template V - The type of values in the map.
- */
-export declare class DataMap<K, V> extends Map<K, V> {
-    /**
-     * An event triggered when a new item is set in the map.
-     */
-    readonly onItemSet: Event<{
-        key: K;
-        value: V;
-    }>;
-    /**
-     * An event triggered when an existing item in the map is updated.
-     */
-    readonly onItemUpdated: Event<{
-        key: K;
-        value: V;
-    }>;
-    /**
-     * An event triggered when an item is deleted from the map.
-     */
-    readonly onItemDeleted: Event<K>;
-    /**
-     * An event triggered when the map is cleared.
-     */
-    readonly onCleared: Event<unknown>;
-    /**
-     * Constructs a new DataMap instance.
-     *
-     * @param iterable - An iterable object containing key-value pairs to populate the map.
-     */
-    constructor(iterable?: Iterable<readonly [K, V]> | null | undefined);
-    /**
-     * Clears the map and triggers the onCleared event.
-     */
-    clear(): void;
-    /**
-     * Sets the value for the specified key in the map.
-     * If the item is new, then onItemSet is triggered.
-     * If the item is already in the map, then onItemUpdated is triggered.
-     *
-     * @param key - The key of the item to set.
-     * @param value - The value of the item to set.
-     * @returns The DataMap instance.
-     */
-    set(key: K, value: V): this;
-    /**
-     * A function that acts as a guard for adding items to the set.
-     * It determines whether a given value should be allowed to be added to the set.
-     *
-     * @param key - The key of the entry to be checked against the guard.
-     * @param value - The value of the entry to be checked against the guard.
-     * @returns A boolean indicating whether the value should be allowed to be added to the set.
-     *          By default, this function always returns true, allowing all values to be added.
-     *          You can override this behavior by providing a custom implementation.
-     */
-    guard: (key: K, value: V) => boolean;
-    /**
-     * Deletes the specified key from the map and triggers the onItemDeleted event if the key was found.
-     *
-     * @param key - The key of the item to delete.
-     * @returns True if the key was found and deleted; otherwise, false.
-     */
-    delete(key: K): boolean;
-    /**
-     * Clears the map and resets the events.
-     */
-    dispose(): void;
-}

package/dist/core/Types/src/data-set.d.ts

@@ -1,58 +0,0 @@
-import { Event } from "./event";
-/**
- * A class that extends the built-in Set class and provides additional functionality. It triggers events when items are added, deleted, or the set is cleared.
- *
- * @template T - The type of elements in the set.
- */
-export declare class DataSet<T> extends Set<T> {
-    /**
-     * An event that is triggered when a new item is added to the set.
-     */
-    readonly onItemAdded: Event<T>;
-    /**
-     * An event that is triggered when an item is deleted from the set.
-     */
-    readonly onItemDeleted: Event<unknown>;
-    /**
-     * An event that is triggered when the set is cleared.
-     */
-    readonly onCleared: Event<unknown>;
-    /**
-     * Constructs a new instance of the DataSet class.
-     *
-     * @param iterable - An optional iterable object to initialize the set with.
-     */
-    constructor(iterable?: Iterable<T> | null);
-    /**
-     * Clears the set and triggers the onCleared event.
-     */
-    clear(): void;
-    /**
-     * Adds one or multiple values to the set and triggers the onItemAdded event per each.
-     *
-     * @param value - The value to add to the set.
-     * @returns - The set instance.
-     */
-    add(...value: T[]): this;
-    /**
-     * A function that acts as a guard for adding items to the set.
-     * It determines whether a given value should be allowed to be added to the set.
-     *
-     * @param value - The value to be checked against the guard.
-     * @returns A boolean indicating whether the value should be allowed to be added to the set.
-     *          By default, this function always returns true, allowing all values to be added.
-     *          You can override this behavior by providing a custom implementation.
-     */
-    guard: (value: T) => boolean;
-    /**
-     * Deletes a value from the set and triggers the onItemDeleted event.
-     *
-     * @param value - The value to delete from the set.
-     * @returns - True if the value was successfully deleted, false otherwise.
-     */
-    delete(value: T): boolean;
-    /**
-     * Clears the set and resets the onItemAdded, onItemDeleted, and onCleared events.
-     */
-    dispose(): void;
-}

package/dist/core/Types/src/event-manager.d.ts

@@ -1,30 +0,0 @@
-import { Event } from "./event";
-import { AsyncEvent } from "./async-event";
-/**
- * Simple class to easily toggle and reset event lists.
- */
-export declare class EventManager {
-    /**
-     * The list of events managed by this instance.
-     */
-    list: Set<Event<any> | AsyncEvent<any>>;
-    /**
-     * Adds events to this manager.
-     * @param events the events to add.
-     */
-    add(events: Iterable<Event<any> | AsyncEvent<any>>): void;
-    /**
-     * Removes events from this manager.
-     * @param events the events to remove.
-     */
-    remove(events: Iterable<Event<any> | AsyncEvent<any>>): void;
-    /**
-     * Sets all the events managed by this instance as enabled or disabled.
-     * @param active whether to turn on or off the events.
-     */
-    set(active: boolean): void;
-    /**
-     * Resets all the events managed by this instance.
-     */
-    reset(): void;
-}

package/dist/core/Types/src/event.d.ts

@@ -1,32 +0,0 @@
-/**
- * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to `this`, you will need to declare the callback as an arrow function.
- */
-export declare class Event<T> {
-    /**
-     * Whether this event is active or not. If not, it won't trigger.
-     */
-    enabled: boolean;
-    /**
-     * Add a callback to this event instance.
-     * @param handler - the callback to be added to this event.
-     */
-    add(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
-    /**
-     * Removes a callback from this event instance.
-     * @param handler - the callback to be removed from this event.
-     */
-    remove(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
-    /** Triggers all the callbacks assigned to this event. */
-    trigger: (data?: T) => void;
-    /** Gets rid of all the suscribed events. */
-    reset(): void;
-    private handlers;
-}

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

@@ -1,15 +0,0 @@
-export * from "./event";
-export * from "./async-event";
-export * from "./interfaces";
-export * from "./component";
-export * from "./base";
-export * from "./base-world-item";
-export * from "./base-camera";
-export * from "./base-renderer";
-export * from "./base-scene";
-export * from "./world";
-export * from "./data-set";
-export * from "./data-map";
-export * from "./component-with-ui";
-export * from "./config-types";
-export * from "./event-manager";

package/dist/core/Types/src/interfaces.d.ts

@@ -1,117 +0,0 @@
-import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { Event } from "./event";
-import { EventManager } from "./event-manager";
-/**
- * Whether this component has to be manually destroyed once you are done with it to prevent [memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects). This also ensures that the DOM events created by that component will be cleaned up.
- */
-export interface Disposable {
-    /**
-     * Destroys the object from memory to prevent a
-     * [memory leak](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
-     */
-    dispose: () => void | Promise<void>;
-    /** Fired after the tool has been disposed.  */
-    readonly onDisposed: Event<any>;
-}
-/**
- * Whether the geometric representation of this component can be hidden or shown in the [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
- */
-export interface Hideable {
-    /**
-     * Whether the geometric representation of this component is
-     * currently visible or not in the
-     * [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
-     */
-    visible: boolean;
-}
-/**
- * Whether this component can be resized. The meaning of this can vary depending on the component: resizing a [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer) component could mean changing its resolution, whereas resizing a [Mesh](https://threejs.org/docs/#api/en/objects/Mesh) would change its scale.
- */
-export interface Resizeable {
-    /**
-     * Sets size of this component (e.g. the resolution of a
-     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
-     * component.
-     */
-    resize: (size?: THREE.Vector2) => void;
-    /** Event that fires when the component has been resized. */
-    onResize: Event<THREE.Vector2>;
-    /**
-     * Gets the current size of this component (e.g. the resolution of a
-     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
-     * component.
-     */
-    getSize: () => THREE.Vector2;
-}
-/** Whether this component should be updated each frame. */
-export interface Updateable {
-    /** Actions that should be executed after updating the component. */
-    onAfterUpdate: Event<any>;
-    /** Actions that should be executed before updating the component. */
-    onBeforeUpdate: Event<any>;
-    /**
-     * Function used to update the state of this component each frame. For
-     * instance, a renderer component will make a render each frame.
-     */
-    update(delta?: number): void;
-}
-/** Basic type to describe the progress of any kind of process. */
-export interface Progress {
-    /** The amount of things that have been done already. */
-    current: number;
-    /** The total amount of things to be done by the process. */
-    total: number;
-}
-/**
- * Whether this component supports create and destroy operations. This generally applies for components that work with instances, such as clipping planes or dimensions.
- */
-export interface Createable {
-    /** Creates a new instance of an element (e.g. a new Dimension). */
-    create: (data: any) => void;
-    /**
-     * Finish the creation process of the component, successfully creating an
-     * instance of whatever the component creates.
-     */
-    endCreation?: (data: any) => void;
-    /**
-     * Cancels the creation process of the component, going back to the state
-     * before starting to create.
-     */
-    cancelCreation?: (data: any) => void;
-    /** Deletes an existing instance of an element (e.g. a Dimension). */
-    delete: (data: any) => void;
-}
-/**
- * Whether this component supports to be configured.
- */
-export interface Configurable<T, U> {
-    /** Wether this components has been already configured. */
-    isSetup: boolean;
-    /** Use the provided configuration to set up the tool. */
-    setup: (config?: Partial<U>) => void | Promise<void>;
-    /** Fired after successfully calling {@link Configurable.setup()}  */
-    readonly onSetup: Event<any>;
-    /** Object holding the tool configuration. You can edit this directly to change the object.
-     */
-    config: Required<T>;
-}
-/**
- * Whether a camera uses the Camera Controls library.
- */
-export interface CameraControllable {
-    /**
-     * An instance of CameraControls that provides camera control functionalities.
-     * This instance is used to manipulate the camera.
-     */
-    controls: CameraControls;
-}
-/**
- * Whether it has events or not.
- */
-export interface Eventable {
-    /**
-     * The object in charge of managing all the events.
-     */
-    eventManager: EventManager;
-}

package/dist/core/Types/src/world.d.ts

@@ -1,34 +0,0 @@
-import * as THREE from "three";
-import { BaseScene } from "./base-scene";
-import { BaseCamera } from "./base-camera";
-import { BaseRenderer } from "./base-renderer";
-import { Updateable, Disposable } from "./interfaces";
-/**
- * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
- */
-export interface World extends Disposable, Updateable {
-    /**
-     * A set of meshes present in the world. This is taken into account for operations like raycasting.
-     */
-    meshes: Set<THREE.Mesh>;
-    /**
-     * The base scene of the world.
-     */
-    scene: BaseScene;
-    /**
-     * The base camera of the world.
-     */
-    camera: BaseCamera;
-    /**
-     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
-     */
-    renderer: BaseRenderer | null;
-    /**
-     * A unique identifier for the world.
-     */
-    uuid: string;
-    /**
-     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
-     */
-    isDisposing: boolean;
-}

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

@@ -1,38 +0,0 @@
-import { World, Component, Disposable, Event, DataMap, Configurable } from "../Types";
-import { Components } from "../Components";
-import { BCFViewpoint, Viewpoint } from "./src";
-import { ViewpointsConfigManager, ViewpointsConfig } from "./src/viewpoints-config";
-export * from "./src";
-export declare class Viewpoints extends Component implements Disposable, Configurable<ViewpointsConfigManager, ViewpointsConfig> {
-    static readonly uuid: "ee867824-a796-408d-8aa0-4e5962a83c66";
-    enabled: boolean;
-    /**
-     * A DataMap that stores Viewpoint instances, indexed by their unique identifiers (guid).
-     * This map is used to manage and retrieve Viewpoint instances within the Viewpoints component.
-     */
-    readonly list: DataMap<string, Viewpoint>;
-    /**
-     * Creates a new Viewpoint instance and adds it to the list.
-     *
-     * @param world - The world in which the Viewpoint will be created.
-     * @param data - Optional partial data for the Viewpoint. If not provided, default data will be used.
-     *
-     * @returns The newly created Viewpoint instance.
-     */
-    create(world: World, data?: Partial<BCFViewpoint>): Viewpoint;
-    constructor(components: Components);
-    isSetup: boolean;
-    setup(): void;
-    onSetup: Event<unknown>;
-    config: ViewpointsConfigManager;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Disposes of the Viewpoints component and its associated resources.
-     *
-     * This method is responsible for cleaning up any resources held by the Viewpoints component,
-     * such as disposing of the DataMap of Viewpoint instances and triggering and resetting the
-     * onDisposed event.
-     */
-    dispose(): void;
-}

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

@@ -1,2 +0,0 @@
-export * from "./types";
-export * from "./viewpoint";

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

@@ -1,36 +0,0 @@
-import { SimplePlane } from "../../Clipper";
-import { DataSet } from "../../Types";
-export interface ViewpointCamera {
-    direction: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    position: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    aspectRatio: number;
-}
-export interface ViewpointPerspectiveCamera extends ViewpointCamera {
-    fov: number;
-}
-export interface ViewpointOrthographicCamera extends ViewpointCamera {
-    viewToWorldScale: number;
-}
-/**
- * Represents a viewpoint in a BCF file.
- */
-export interface BCFViewpoint {
-    title?: string;
-    guid: string;
-    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
-    selectionComponents: Iterable<string>;
-    exceptionComponents: Iterable<string>;
-    clippingPlanes: DataSet<SimplePlane>;
-    spacesVisible: boolean;
-    spaceBoundariesVisible: boolean;
-    openingsVisible: boolean;
-    defaultVisibility: boolean;
-}

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 {};