@thatopen/components 2.4.11 → 3.1.0

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

@@ -1,195 +0,0 @@
-import * as WEBIFC from "web-ifc";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Disposable, Event, Component, Components } from "../../core";
-import { RelationsMap, ModelsRelationMap, InverseAttribute, IfcRelation, RelationsProcessingConfig, EntitiesRelatedEvent } from "./src";
-/**
- * Indexer component for IFC entities, facilitating the indexing and retrieval of IFC entity relationships. It is designed to process models properties by indexing their IFC entities' relations based on predefined inverse attributes, and provides methods to query these relations. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcRelationsIndexer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcRelationsIndexer).
- */
-export declare class IfcRelationsIndexer 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: "23a889ab-83b3-44a4-8bee-ead83438370b";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * Event triggered when relations for a model have been indexed.
-     * This event provides the model's UUID and the relations map generated for that model.
-     *
-     * @property {string} modelID - The UUID of the model for which relations have been indexed.
-     * @property {RelationsMap} relationsMap - The relations map generated for the specified model.
-     * The map keys are expressIDs of entities, and the values are maps where each key is a relation type ID and its value is an array of expressIDs of entities related through that relation type.
-     */
-    readonly onRelationsIndexed: Event<{
-        modelID: string;
-        relationsMap: RelationsMap;
-    }>;
-    /**
-     * Holds the relationship mappings for each model processed by the indexer.
-     * The structure is a map where each key is a model's UUID, and the value is another map.
-     * This inner map's keys are entity expressIDs, and its values are maps where each key is an index
-     * representing a specific relation type, and the value is an array of expressIDs of entities
-     * that are related through that relation type. This structure allows for efficient querying
-     * of entity relationships within a model.
-     */
-    readonly relationMaps: ModelsRelationMap;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    private _relToAttributesMap;
-    private _inverseAttributes;
-    private _ifcRels;
-    constructor(components: Components);
-    private onFragmentsDisposed;
-    private indexRelations;
-    getAttributeIndex(inverseAttribute: InverseAttribute): number;
-    /**
-     * Adds a relation map to the model's relations map.
-     *
-     * @param model - The `FragmentsGroup` model to which the relation map will be added.
-     * @param relationMap - The `RelationsMap` to be added to the model's relations map.
-     *
-     * @fires onRelationsIndexed - Triggers an event with the model's UUID and the added relation map.
-     */
-    setRelationMap(model: FragmentsGroup, relationMap: RelationsMap): void;
-    /**
-     * Processes a given model to index its IFC entities relations based on predefined inverse attributes.
-     * This method iterates through each specified inverse attribute, retrieves the corresponding relations,
-     * and maps them in a structured way to facilitate quick access to related entities.
-     *
-     * The process involves querying the model for each relation type associated with the inverse attributes
-     * and updating the internal relationMaps with the relationships found. This map is keyed by the model's UUID
-     * and contains a nested map where each key is an entity's expressID and its value is another map.
-     * This inner map's keys are the indices of the inverse attributes, and its values are arrays of expressIDs
-     * of entities that are related through that attribute.
-     *
-     * @param model The `FragmentsGroup` model to be processed. It must have properties loaded.
-     * @returns A promise that resolves to the relations map for the processed model. This map is a detailed
-     * representation of the relations indexed by entity expressIDs and relation types.
-     * @throws An error if the model does not have properties loaded.
-     */
-    process(model: FragmentsGroup, config?: Partial<RelationsProcessingConfig>): Promise<RelationsMap>;
-    /**
-     * Processes a given model from a WebIfc API to index its IFC entities relations.
-     *
-     * @param ifcApi - The WebIfc API instance from which to retrieve the model's properties.
-     * @param modelID - The unique identifier of the model within the WebIfc API.
-     * @returns A promise that resolves to the relations map for the processed model.
-     *          This map is a detailed representation of the relations indexed by entity expressIDs and relation types.
-     */
-    processFromWebIfc(ifcApi: WEBIFC.IfcAPI, modelID: number): Promise<RelationsMap>;
-    /**
-     * Retrieves the relations of a specific entity within a model based on the given relation name.
-     * This method searches the indexed relation maps for the specified model and entity,
-     * returning the IDs of related entities if a match is found.
-     *
-     * @param model The `FragmentsGroup` model containing the entity, or its UUID.
-     * @param expressID The unique identifier of the entity within the model.
-     * @param attribute The IFC schema inverse attribute of the relation to search for (e.g., "IsDefinedBy", "ContainsElements").
-     * @returns An array of express IDs representing the related entities. If the array is empty, no relations were found.
-     */
-    getEntityRelations(model: FragmentsGroup | string | RelationsMap, expressID: number, attribute: InverseAttribute): number[];
-    /**
-     * Serializes the relations of a given relation map into a JSON string.
-     * This method iterates through the relations in the given map, organizing them into a structured object where each key is an expressID of an entity,
-     * and its value is another object mapping relation indices to arrays of related entity expressIDs.
-     * The resulting object is then serialized into a JSON string.
-     *
-     * @param relationMap - The map of relations to be serialized. The map keys are expressIDs of entities, and the values are maps where each key is a relation type ID and its value is an array of expressIDs of entities related through that relation type.
-     * @returns A JSON string representing the serialized relations of the given relation map.
-     */
-    serializeRelations(relationMap: RelationsMap): string;
-    /**
-     * Serializes the relations of a specific model into a JSON string.
-     * This method iterates through the relations indexed for the given model,
-     * organizing them into a structured object where each key is an expressID of an entity,
-     * and its value is another object mapping relation indices to arrays of related entity expressIDs.
-     * The resulting object is then serialized into a JSON string.
-     *
-     * @param model The `FragmentsGroup` model whose relations are to be serialized.
-     * @returns A JSON string representing the serialized relations of the specified model.
-     * If the model has no indexed relations, `null` is returned.
-     */
-    serializeModelRelations(model: FragmentsGroup): string | null;
-    /**
-     * Serializes all relations of every model processed by the indexer into a JSON string.
-     * This method iterates through each model's relations indexed in `relationMaps`, organizing them
-     * into a structured JSON object. Each top-level key in this object corresponds to a model's UUID,
-     * and its value is another object mapping entity expressIDs to their related entities, categorized
-     * by relation types. The structure facilitates easy access to any entity's relations across all models.
-     *
-     * @returns A JSON string representing the serialized relations of all models processed by the indexer.
-     *          If no relations have been indexed, an empty object is returned as a JSON string.
-     */
-    serializeAllRelations(): string;
-    /**
-     * Converts a JSON string representing relations between entities into a structured map.
-     * This method parses the JSON string to reconstruct the relations map that indexes
-     * entity relations by their express IDs. The outer map keys are the express IDs of entities,
-     * and the values are maps where each key is a relation type ID and its value is an array
-     * of express IDs of entities related through that relation type.
-     *
-     * @param json The JSON string to be parsed into the relations map.
-     * @returns A `Map` where the key is the express ID of an entity as a number, and the value
-     * is another `Map`. This inner map's key is the relation type ID as a number, and its value
-     * is an array of express IDs (as numbers) of entities related through that relation type.
-     */
-    getRelationsMapFromJSON(json: string): RelationsMap;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Retrieves the entities within a model that have a specific relation with a given entity.
-     *
-     * @param model - The BIM model to search for related entities.
-     * @param inv - The IFC schema inverse attribute of the relation to search for (e.g., "IsDefinedBy", "ContainsElements").
-     * @param expressID - The expressID of the entity within the model.
-     *
-     * @returns A `Set` with the expressIDs of the entities that have the specified relation with the given entity.
-     *
-     * @throws An error if the model relations are not indexed or if the inverse attribute name is invalid.
-     */
-    getEntitiesWithRelation(model: FragmentsGroup, inv: InverseAttribute, expressID: number): Set<number>;
-    /**
-     * Adds relations between an entity and other entities in a BIM model.
-     *
-     * @param model - The BIM model to which the relations will be added.
-     * @param expressID - The expressID of the entity within the model.
-     * @param relationName - The IFC schema inverse attribute of the relation to add (e.g., "IsDefinedBy", "ContainsElements").
-     * @param relIDs - The expressIDs of the related entities within the model.
-     * @deprecated Use addEntitiesRelation instead. This will be removed in future versions.
-     *
-     * @throws An error if the relation name is not a valid relation name.
-     */
-    addEntityRelations(model: FragmentsGroup, expressID: number, relationName: InverseAttribute, ...relIDs: number[]): void;
-    /**
-     * Converts the relations made into actual IFC data.
-     *
-     * @remarks This function iterates through the changes made to the relations and applies them to the corresponding BIM model.
-     * It only make sense to use it if the relations need to be write in the IFC file.
-     *
-     * @returns A promise that resolves when all the relation changes have been applied.
-     */
-    applyRelationChanges(): Promise<void>;
-    private readonly _changeMap;
-    /**
-     * An event that is triggered when entities are related in a BIM model.
-     * The event provides information about the type of relation, the inverse attribute,
-     * the IDs of the entities related, and the IDs of the entities that are being related.
-     */
-    readonly onEntitiesRelated: Event<EntitiesRelatedEvent>;
-    addEntitiesRelation(model: FragmentsGroup, relatingID: number, rel: {
-        type: IfcRelation;
-        inv: InverseAttribute;
-    }, ...relatedIDs: number[]): void;
-    /**
-     * Gets the children of the given element recursively. E.g. in a model with project - site - building - storeys - rooms, passing a storey will include all its children and the children of the rooms contained in it.
-     *
-     * @param model The BIM model whose children to get.
-     * @param expressID The expressID of the item whose children to get.
-     * @param found An optional parameter that includes a set of expressIDs where the found element IDs will be added.
-     *
-     * @returns A `Set` with the expressIDs of the found items.
-     */
-    getEntityChildren(model: FragmentsGroup, expressID: number, found?: Set<number>): Set<number>;
-}
-export * from "./src";

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

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

package/dist/ifc/IfcRelationsIndexer/src/newVersion.d.ts

@@ -1,51 +0,0 @@
-declare const actual: {
-    186: {
-        7: number[];
-    };
-    250: {
-        8: number[];
-    };
-    253: {
-        8: number[];
-    };
-    257: {
-        8: number[];
-    };
-};
-declare const newVersion: {
-    186: {
-        7: ({
-            259: number[];
-            263?: undefined;
-            266?: undefined;
-        } | {
-            263: number[];
-            259?: undefined;
-            266?: undefined;
-        } | {
-            266: number[];
-            259?: undefined;
-            263?: undefined;
-        })[];
-    };
-    190: {
-        7: {
-            259: number[];
-        }[];
-    };
-    250: {
-        8: {
-            259: number[];
-        }[];
-    };
-};
-interface V2Schema {
-    [expressID: number]: {
-        [invAttrIndex: number]: {
-            [IfcRelationship: number]: number[];
-        };
-    };
-}
-type RelationsMap = Map<number, Map<number, {
-    [ifcRel: number]: number[];
-}>>;

package/dist/ifc/IfcRelationsIndexer/src/relToAttributesMap.d.ts

@@ -1,5 +0,0 @@
-import { InverseAttribute } from "./types";
-export declare const relToAttributesMap: Map<160246688 | 2655215786 | 919958153 | 1307041759 | 4186316022 | 781010003 | 307848117 | 3242617779 | 279856033 | 1204542856 | 2857406711 | 2565941209 | 2495723537 | 3268803585 | 982818633, {
-    forRelating: InverseAttribute;
-    forRelated: InverseAttribute;
-}>;

package/dist/ifc/IfcRelationsIndexer/src/types.d.ts

@@ -1,73 +0,0 @@
-import * as WEBIFC from "web-ifc";
-export type RelationsMap = Map<number, Map<number, number[]>>;
-export interface ModelsRelationMap {
-    [modelID: string]: RelationsMap;
-}
-/**
- * Type alias for an array of inverse attribute names.
- */
-export type InverseAttributes = [
-    "IsDecomposedBy",
-    "Decomposes",
-    "AssociatedTo",
-    "HasAssociations",
-    "ClassificationForObjects",
-    "IsGroupedBy",
-    "HasAssignments",
-    "IsDefinedBy",
-    "DefinesOcurrence",
-    "IsTypedBy",
-    "Types",
-    "Defines",
-    "ContainedInStructure",
-    "ContainsElements",
-    "HasControlElements",
-    "AssignedToFlowElement",
-    "ConnectedTo",
-    "ConnectedFrom",
-    "ReferencedBy",
-    "Declares",
-    "HasContext",
-    "Controls",
-    "IsNestedBy",
-    "Nests",
-    "DocumentRefForObjects"
-];
-export type InverseAttribute = InverseAttributes[number];
-/**
- * Type alias for an array of IfcRelation types from WebIfc.
- */
-export type IfcRelations = [
-    typeof WEBIFC.IFCRELAGGREGATES,
-    typeof WEBIFC.IFCRELASSOCIATESMATERIAL,
-    typeof WEBIFC.IFCRELASSOCIATESCLASSIFICATION,
-    typeof WEBIFC.IFCRELASSIGNSTOGROUP,
-    typeof WEBIFC.IFCRELDEFINESBYPROPERTIES,
-    typeof WEBIFC.IFCRELDEFINESBYTYPE,
-    typeof WEBIFC.IFCRELDEFINESBYTEMPLATE,
-    typeof WEBIFC.IFCRELCONTAINEDINSPATIALSTRUCTURE,
-    typeof WEBIFC.IFCRELFLOWCONTROLELEMENTS,
-    typeof WEBIFC.IFCRELCONNECTSELEMENTS,
-    typeof WEBIFC.IFCRELASSIGNSTOPRODUCT,
-    typeof WEBIFC.IFCRELDECLARES,
-    typeof WEBIFC.IFCRELASSIGNSTOCONTROL,
-    typeof WEBIFC.IFCRELNESTS,
-    typeof WEBIFC.IFCRELASSOCIATESDOCUMENT
-];
-export type IfcRelation = IfcRelations[number];
-export interface RelationsProcessingConfig {
-    relationsToProcess: IfcRelation[];
-}
-/**
- * Interface definition of an Entities Related Event from the IfcRelationsIndexer. This event gets triggered when two or more entities has been related with each other.
- */
-export interface EntitiesRelatedEvent {
-    /** The type of the IFC relation. */
-    relType: IfcRelation;
-    /** The inverse attribute of the relation. */
-    invAttribute: InverseAttribute;
-    /** The IDs of the entities that are relating. */
-    relatingIDs: number[];
-    /** The IDs of the entities that are being related. */
-    relatedIDs: number[];
-}

package/dist/ifc/Utils/ifc-categories.d.ts

@@ -1,7 +0,0 @@
-import * as WEBIFC from "web-ifc";
-export interface IfcItemsCategories {
-    [itemID: number]: number;
-}
-export declare class IfcCategories {
-    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
-}

package/dist/ifc/Utils/ifc-category-case.d.ts

@@ -1,3 +0,0 @@
-export declare const ifcCategoryCase: {
-    [upperCase: string]: string;
-};

package/dist/ifc/Utils/ifc-category-map.d.ts

@@ -1,6 +0,0 @@
-/**
- * A map that associates each unique integer identifier (IFC Entity ID) with its corresponding category name. This map is used to map IFC entities to their respective categories for easier identification and processing.
- */
-export declare const IfcCategoryMap: {
-    [key: number]: string;
-};

package/dist/ifc/Utils/ifc-elements-map.d.ts

@@ -1,11 +0,0 @@
-/**
- * A map of IFC element types to their corresponding names. The keys are the IFC entity type numbers, and the values are the names of the IFC entities.
- *
- * @remarks
- * This map is used to provide a mapping between IFC entity type numbers and their names.
- * It is useful for identifying and processing different types of IFC elements in a project.
- *
- */
-export declare const IfcElements: {
-    [key: number]: string;
-};

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

@@ -1,5 +0,0 @@
-export * from "./ifc-categories";
-export * from "./ifc-elements-map";
-export * from "./ifc-category-map";
-export * from "./properties-utils";
-export * from "./ifc-category-case";

package/dist/ifc/Utils/properties-utils.d.ts

@@ -1,25 +0,0 @@
-import * as FRAGS from "@thatopen/fragments";
-export declare class IfcPropertiesUtils {
-    static getUnits(group: FRAGS.FragmentsGroup): Promise<number>;
-    static findItemByGuid(model: FRAGS.FragmentsGroup, guid: string): Promise<{
-        [attribute: string]: any;
-    } | null>;
-    static getRelationMap(model: FRAGS.FragmentsGroup, relationType: number, onElementsFound?: (relatingID: number, relatedIDs: number[]) => Promise<void>): Promise<{
-        [relatingID: number]: number[];
-    }>;
-    static getQsetQuantities(model: FRAGS.FragmentsGroup, expressID: number, onQuantityFound?: (expressID: number) => void): Promise<number[] | null>;
-    static getPsetProps(model: FRAGS.FragmentsGroup, expressID: number, onPropFound?: (expressID: number) => void): Promise<number[] | null>;
-    static getPsetRel(model: FRAGS.FragmentsGroup, psetID: number): Promise<number | null>;
-    static getQsetRel(model: FRAGS.FragmentsGroup, qsetID: number): Promise<number | null>;
-    static getEntityName(model: FRAGS.FragmentsGroup, entityID: number): Promise<{
-        key: string | null;
-        name: string | null;
-    }>;
-    static getQuantityValue(model: FRAGS.FragmentsGroup, quantityID: number): Promise<{
-        key: string | null;
-        value: number | null;
-    }>;
-    static isRel(expressID: number): boolean;
-    static attributeExists(model: FRAGS.FragmentsGroup, expressID: number, attribute: string): Promise<boolean>;
-    static groupEntitiesByType(model: FRAGS.FragmentsGroup, expressIDs: Set<number> | number[]): Promise<Map<number, Set<number>>>;
-}

package/dist/ifc/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./IfcJsonExporter";
-export * from "./IfcIsolator";
-export * from "./IfcRelationsIndexer";
-export * from "./IfcPropertiesManager";
-export * from "./Utils";
-export * from "./IfcFinder";

package/dist/measurement/MeasurementUtils/index.d.ts

@@ -1,105 +0,0 @@
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Component, Components } from "../../core";
-/**
- * Represents an edge measurement result.
- */
-export interface MeasureEdge {
-    /**
-     * The distance between the two points of the edge.
-     */
-    distance: number;
-    /**
-     * The two points that define the edge.
-     */
-    points: THREE.Vector3[];
-}
-/**
- * Utility component for performing measurements on 3D meshes by providing methods for measuring distances between edges and faces. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MeasurementUtils). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MeasurementUtils).
- */
-export declare class MeasurementUtils extends Component {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static uuid: string;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Utility method to calculate the distance from a point to a line segment.
-     *
-     * @param point - The point from which to calculate the distance.
-     * @param lineStart - The start point of the line segment.
-     * @param lineEnd - The end point of the line segment.
-     * @param clamp - If true, the distance will be clamped to the line segment's length.
-     * @returns The distance from the point to the line segment.
-     */
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
-    /**
-     * Method to get the face of a mesh that contains a given triangle index.
-     * It also returns the edges of the found face and their indices.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param triangleIndex - The index of the triangle within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the edges of the found face and their indices, or null if no face was found.
-     */
-    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
-    /**
-     * Method to get the vertices and normal of a mesh face at a given index.
-     * It also applies instance transformation if provided.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param faceIndex - The index of the face within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the vertices and normal of the face.
-     * @throws Will throw an error if the geometry is not indexed.
-     */
-    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
-    /**
-     * Method to round the vector's components to a specified number of decimal places.
-     * This is used to ensure numerical precision in edge detection.
-     *
-     * @param vector - The vector to round.
-     * @returns The vector with rounded components.
-     */
-    round(vector: THREE.Vector3): void;
-    /**
-     * Calculates the volume of a set of fragments.
-     *
-     * @param frags - A map of fragment IDs to their corresponding item IDs.
-     * @returns The total volume of the fragments and the bounding sphere.
-     *
-     * @remarks
-     * This method creates a set of instanced meshes from the given fragments and item IDs.
-     * It then calculates the volume of each mesh and returns the total volume and its bounding sphere.
-     *
-     * @throws Will throw an error if the geometry of the meshes is not indexed.
-     * @throws Will throw an error if the fragment manager is not available.
-     */
-    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
-    /**
-     * Calculates the total volume of a set of meshes.
-     *
-     * @param meshes - An array of meshes or instanced meshes to calculate the volume from.
-     * @returns The total volume of the meshes and the bounding sphere.
-     *
-     * @remarks
-     * This method calculates the volume of each mesh in the provided array and returns the total volume
-     * and its bounding sphere.
-     *
-     */
-    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
-    private getFaceData;
-    private getVolumeOfMesh;
-    private getSignedVolumeOfTriangle;
-}

package/dist/measurement/index.d.ts

@@ -1 +0,0 @@
-export * from "./MeasurementUtils";