@thatopen/components 2.0.0-alpha.5 → 2.0.0-alpha.7

package/dist/core/Cullers/src/culler-renderer.d.ts

@@ -1,6 +1,6 @@
 import * as THREE from "three";
 import { Components } from "../../Components";
-import { Event, World } from "../../Types";
+import { AsyncEvent, Event, World } from "../../Types";
 export interface CullerRendererSettings {
     updateInterval?: number;
     width?: number;
@@ -18,7 +18,7 @@ export declare class CullerRenderer {
      * meshes that are currently visible, and the ones that were visible
      * just before but not anymore.
      */
-    readonly onViewUpdated: Event<any>;
+    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
     /** {@link Component.enabled} */
     enabled: boolean;
     /**
@@ -44,6 +44,7 @@ export declare class CullerRenderer {
     private readonly renderTarget;
     private readonly bufferSize;
     private readonly _buffer;
+    protected _isWorkerBusy: boolean;
     constructor(components: Components, world: World, settings?: CullerRendererSettings);
     /** {@link Disposable.dispose} */
     dispose(): void;

package/dist/core/Cullers/src/mesh-culler-renderer.d.ts

@@ -17,6 +17,7 @@ export declare class MeshCullerRenderer extends CullerRenderer {
     private _meshIDColorCodeMap;
     private _currentVisibleMeshes;
     private _recentlyHiddenMeshes;
+    private _intervalID;
     private readonly _transparentMat;
     constructor(components: Components, world: World, settings?: CullerRendererSettings);
     dispose(): void;

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

@@ -0,0 +1,34 @@
+/**
+ * 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 AsyncEvent<T> {
+    /**
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
+     */
+    add(handler: T extends void ? {
+        (): Promise<void>;
+    } : {
+        (data: T): Promise<void>;
+    }): void;
+    /**
+     * Removes a callback from this event instance.
+     * @param handler - the callback to be removed from this event.
+     */
+    remove(handler: T extends void ? {
+        (): Promise<void>;
+    } : {
+        (data: T): Promise<void>;
+    }): void;
+    /** Triggers all the callbacks assigned to this event. */
+    trigger: (data?: T) => Promise<void>;
+    /** Gets rid of all the suscribed events. */
+    reset(): void;
+    private handlers;
+}

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

@@ -1,4 +1,5 @@
 export * from "./event";
+export * from "./async-event";
 export * from "./interfaces";
 export * from "./component";
 export * from "./base";

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

@@ -0,0 +1,106 @@
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Disposable, Event, Component, Components } from "../../core";
+interface RelationMap {
+    [modelID: string]: Map<number, Map<number, number[]>>;
+}
+/**
+ * Indexer 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.
+ */
+export declare class IfcRelationsIndexer extends Component implements Disposable {
+    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    enabled: boolean;
+    /**
+     * All the inverse attributes this component can processes.
+     */
+    readonly inverseAttributes: string[];
+    inverseAttributesToProcess: string[];
+    private _relToAttributesMap;
+    /**
+     * 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: RelationMap;
+    constructor(components: Components);
+    private onFragmentsDisposed;
+    private getAttributeRels;
+    private setRelMap;
+    /**
+     * 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): Promise<Map<number, Map<number, number[]>>>;
+    /**
+     * 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.
+     * @param expressID The unique identifier of the entity within the model.
+     * @param relationName 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, or `null` if no relations are found
+     * or the specified relation name is not indexed.
+     */
+    getEntityRelations(model: FragmentsGroup, expressID: number, relationName: string): number[] | null;
+    /**
+     * 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.
+     */
+    serializeRelations(): 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): Map<number, Map<number, number[]>>;
+    /**
+     * Disposes the component, cleaning up resources and detaching event listeners.
+     * This ensures that the component is properly cleaned up and does not leave behind any
+     * references that could prevent garbage collection.
+     */
+    dispose(): void;
+}
+export {};

package/dist/ifc/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./IfcJsonExporter";
 export * from "./IfcPropertiesFinder";
-export * from "./IfcPropertiesIndexer";
+export * from "./IfcRelationsIndexer";
 export * from "./IfcPropertiesManager";
 export * from "./Utils";