@thatopen/components 2.0.0-alpha.2 → 2.0.0-alpha.4

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

@@ -40,7 +40,7 @@ export declare class Clipper<T extends SimplePlane> extends Component implements
      * has to be `true` for this to apply.
      */
     toleranceOrthogonalY: number;
-    planes: T[];
+    list: T[];
     protected PlaneType: new (...args: any) => SimplePlane | T;
     /** The material used in all the clipping planes. */
     protected _material: THREE.Material;

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

@@ -63,7 +63,7 @@ export interface Updateable {
      * 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 | Promise<void>;
+    update(delta?: number): void;
 }
 /** Basic type to describe the progress of any kind of process. */
 export interface Progress {
@@ -78,31 +78,20 @@ export interface Progress {
  * dimensions.
  */
 export interface Createable {
-    readonly onBeforeCreate: Event<any>;
     /** Creates a new instance of an element (e.g. a new Dimension). */
     create: (data: any) => void;
-    /** Fired after successfully calling {@link Createable.create}  */
-    readonly onAfterCreate: Event<any>;
     /**
      * Finish the creation process of the component, successfully creating an
      * instance of whatever the component creates.
      */
-    endCreation: (data: any) => void;
-    /** Fired before calling {@link Createable.cancelCreation}. */
-    readonly onBeforeCancel: Event<any>;
+    endCreation?: (data: any) => void;
     /**
      * Cancels the creation process of the component, going back to the state
      * before starting to create.
      */
-    cancelCreation: (data: any) => void;
-    /** Fired after calling {@link Createable.cancelCreation}. */
-    readonly onAfterCancel: Event<any>;
-    /** Fired before calling {@link Createable.delete}. */
-    readonly onBeforeDelete: Event<any>;
+    cancelCreation?: (data: any) => void;
     /** Deletes an existing instance of an element (e.g. a Dimension). */
     delete: (data: any) => void;
-    /** Fired after successfully calling {@link Createable.delete()}  */
-    readonly onAfterDelete: Event<any>;
 }
 /**
  * Whether this component supports to be configured.

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

@@ -0,0 +1,10 @@
+import * as FRAGS from "bim-fragment";
+import { Components, Component } from "../../core";
+export declare class FragmentHider extends Component {
+    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+    enabled: boolean;
+    constructor(components: Components);
+    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
+    isolate(items: FRAGS.FragmentIdMap): void;
+    private updateCulledVisibility;
+}

package/dist/fragments/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./FragmentBoundingBox";
 export * from "./FragmentClassifier";
+export * from "./FragmentExploder";
+export * from "./FragmentHider";
 export * from "./FragmentIfcLoader";
 export * from "./FragmentIfcStreamer";
 export * from "./FragmentManager";

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

@@ -1,31 +1,77 @@
 import { FragmentsGroup } from "bim-fragment";
 import { Disposable, Event, Component, Components } from "../../core";
-import { IfcPropertiesManager } from "../IfcPropertiesManager";
-interface IndexMap {
-    [modelID: string]: {
-        [expressID: string]: Set<number>;
-    };
+interface RelationMap {
+    [modelID: string]: Map<number, Map<number, number[]>>;
 }
 export declare class IfcPropertiesIndexer extends Component implements Disposable {
     static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<string>;
     enabled: boolean;
-    relationsToProcess: number[];
-    indexMap: IndexMap;
-    private _propertiesManager;
-    readonly onPropertiesManagerSet: Event<IfcPropertiesManager>;
-    set propertiesManager(manager: IfcPropertiesManager | null);
-    get propertiesManager(): IfcPropertiesManager | null;
+    /**
+     * All the inverse attributes this component can processes.
+     */
+    readonly inverseAttributes: string[];
+    inverseAttributesToProcess: string[];
+    private _relToAttributesMap;
+    readonly relationMaps: RelationMap;
     constructor(components: Components);
     private onFragmentsDisposed;
-    dispose(): Promise<void>;
-    getProperties(model: FragmentsGroup, id: string): Promise<any[] | null>;
-    private getNestedPsets;
-    private getPsetProperties;
-    process(model: FragmentsGroup): Promise<void>;
-    private setEntityIndex;
-    private cloneProperty;
-    private clonePropertyArray;
+    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;
+    getRelationsMapFromJSON(json: string): Map<number, Map<number, number[]>>;
+    dispose(): void;
 }
 export {};