@thatopen/components 2.4.10 → 3.1.0

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

@@ -1,208 +0,0 @@
-import * as THREE from "three";
-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. 📕 [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";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    private _absoluteMin;
-    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;
-    /**
-     * Uses a FragmentIdMap to add its meshes to the bb calculation.
-     *
-     * This method iterates through the provided `fragmentIdMap`, retrieves the corresponding fragment from the `FragmentsManager`,
-     * and then calls the `addMesh` method for each fragment's mesh, passing the expression IDs as the second parameter.
-     *
-     * @param fragmentIdMap - A mapping of fragment IDs to their corresponding expression IDs.
-     *
-     * @remarks
-     * This method is used to add a mapping of fragment IDs to their corresponding expression IDs.
-     * It ensures that the bounding box calculations are accurate and up-to-date by updating the internal minimum and maximum vectors.
-     *
-     * @example
-     * ```typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * const fragmentIdMap: FRAGS.FragmentIdMap = {
-     *   '5991fa75-2eef-4825-90b3-85177f51a9c9': [123, 245, 389],
-     *   '3469077e-39bf-4fc9-b3e6-4a1d78ad52b0': [454, 587, 612],
-     * };
-     * boundingBoxer.addFragmentIdMap(fragmentIdMap);
-     * ```
-     */
-    addFragmentIdMap(fragmentIdMap: FRAGS.FragmentIdMap): void;
-    private static getFragmentBounds;
-}

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

@@ -1,197 +0,0 @@
-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 with extra information.
- */
-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 an object containing a map of fragment IDs with extra information.
-         */
-        [groupName: string]: {
-            map: FRAGS.FragmentIdMap;
-            name: string;
-            id: number | null;
-        };
-    };
-}
-interface ExportedClassification {
-    [system: string]: {
-        [groupName: string]: {
-            map: {
-                [name: string]: number[];
-            };
-            name: string;
-            id: number | null;
-        };
-    };
-}
-/**
- * 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.
-     * @param config - The configuration for the classifier. It includes "useProperties", which is true by default
-     * (if false, the classification will use the expressIDs instead of the names), and "isolate", which will make
-     * the classifier just pick the WEBIFC categories provided.
-     *
-     * @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, config?: {
-        useProperties?: boolean;
-        isolate?: Set<number>;
-        systemName?: string;
-    }): 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;
-    /**
-     * Exports the computed classification to persists them and import them back
-     * later for faster loading.
-     */
-    export(): ExportedClassification;
-    /**
-     * Imports a classification previously exported with .export().
-     * @param data the serialized classification to import.
-     */
-    import(data: ExportedClassification): void;
-    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number, parentID?: number | null): void;
-}
-export {};

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

@@ -1,50 +0,0 @@
-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;
-    /**
-     * 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

@@ -1,152 +0,0 @@
-import { Fragment, FragmentsGroup } from "@thatopen/fragments";
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Component, Components, Event, Disposable, DataMap } from "../../core";
-import { RelationsMap } from "../../ifc/IfcRelationsIndexer/src/types";
-/**
- * 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[];
-    }>;
-    /**
-     * DataMap containing all loaded fragments.
-     * The key is the fragment's unique identifier, and the value is the fragment itself.
-     */
-    readonly list: DataMap<string, Fragment>;
-    /**
-     * DataMap containing all loaded fragment groups.
-     * The key is the group's unique identifier, and the value is the group itself.
-     */
-    readonly groups: DataMap<string, FragmentsGroup>;
-    baseCoordinationModel: string;
-    baseCoordinationMatrix: THREE.Matrix4;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    private _loader;
-    /**
-     * 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 binary file that contain fragment geometry.
-     * @param data - The binary data to load.
-     * @param config - Optional configuration for loading.
-     * @param config.isStreamed - Optional setting to determine whether this model is streamed or not.
-     * @param config.coordinate - Whether to apply coordinate transformation. Default is true.
-     * @param config.properties - Ifc properties to set on the loaded fragments. Not to be used when streaming.
-     * @returns The loaded FragmentsGroup.
-     */
-    load(data: Uint8Array, config?: Partial<{
-        coordinate: boolean;
-        name: string;
-        properties: FRAGS.IfcProperties;
-        relationsMap: RelationsMap;
-        isStreamed?: boolean;
-    }>): FragmentsGroup;
-    /**
-     * Export the specified fragmentsgroup to binary data.
-     * @param group - the fragments group to be exported.
-     * @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;
-    /**
-     * Converts a collection of IFC GUIDs to a fragmentIdMap.
-     *
-     * @param guids - An iterable collection of global IDs to be converted to a fragment ID map.
-     *
-     * @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.
-     * 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 models are used.
-     */
-    coordinate(models?: FragmentsGroup[]): void;
-    /**
-     * Applies the base coordinate system to the provided object.
-     *
-     * This function takes an object and its original coordinate system as input.
-     * It then inverts the original coordinate system and applies the base coordinate system
-     * to the object. This ensures that the object's position, rotation, and scale are
-     * transformed to match the base coordinate system (which is taken from the first model loaded).
-     *
-     * @param object - The object to which the base coordinate system will be applied.
-     * This should be an instance of THREE.Object3D.
-     *
-     * @param originalCoordinateSystem - The original coordinate system of the object.
-     * This should be a THREE.Matrix4 representing the object's transformation matrix.
-     */
-    applyBaseCoordinateSystem(object: THREE.Object3D | THREE.Vector3, originalCoordinateSystem?: THREE.Matrix4): void;
-    /**
-     * Creates a copy of the whole model or a part of it.
-     *
-     * @param model - The model to clone.
-     * @param items - Optional - The part of the model to be cloned. If not given, the whole group is cloned.
-     *
-     */
-    clone(model: FRAGS.FragmentsGroup, items?: FRAGS.FragmentIdMap): FragmentsGroup;
-}

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

@@ -1,38 +0,0 @@
-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;
-}