@thatopen/components 2.0.0-alpha.6 → 2.0.0-alpha.8

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

@@ -43,7 +43,7 @@ export declare class Clipper<T extends SimplePlane> extends Component implements
     list: T[];
     protected PlaneType: new (...args: any) => SimplePlane | T;
     /** The material used in all the clipping planes. */
-    protected _material: THREE.Material;
+    protected _material: THREE.MeshBasicMaterial;
     private _size;
     private _enabled;
     private _visible;
@@ -56,9 +56,9 @@ export declare class Clipper<T extends SimplePlane> extends Component implements
     /** {@link Hideable.visible } */
     set visible(state: boolean);
     /** The material of the clipping plane representation. */
-    get material(): THREE.Material;
+    get material(): THREE.MeshBasicMaterial;
     /** The material of the clipping plane representation. */
-    set material(material: THREE.Material);
+    set material(material: THREE.MeshBasicMaterial);
     /** The size of the geometric representation of the clippings planes. */
     get size(): number;
     /** The size of the geometric representation of the clippings planes. */

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

@@ -1,5 +1,5 @@
 import * as THREE from "three";
-import { Component, Disposable, Event, World } from "../Types";
+import { Component, Disposable, Event } from "../Types";
 import { Components } from "../Components";
 /**
  * A tool to easily handle the materials of massive amounts of
@@ -9,7 +9,6 @@ export declare class Materials extends Component implements Disposable {
     static readonly uuid: "24989d27-fa2f-4797-8b08-35918f74e502";
     /** {@link Component.enabled} */
     enabled: boolean;
-    private _originalBackground;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<string>;
     list: {
@@ -20,6 +19,8 @@ export declare class Materials extends Component implements Disposable {
     };
     private _originals;
     constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
      * Turns the specified material styles on or off.
      *
@@ -27,19 +28,6 @@ export declare class Materials extends Component implements Disposable {
      * @param ids the ids of the style to turn on or off.
      */
     set(active: boolean, ids?: string[]): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Sets the color of the background of the scene.
-     *
-     * @param color: the color to apply.
-     */
-    setBackgroundColor(color: THREE.Color, world: World): void;
-    /**
-     * Resets the scene background to the color that was being used
-     * before applying the material manager.
-     */
-    resetBackgroundColor(world: World): void;
     /**
      * Creates a new material style.
      * @param id the identifier of the style to create.

package/dist/core/Worlds/src/simple-renderer.d.ts

@@ -6,15 +6,15 @@ import { Components } from "../../Components";
  * ([Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
  */
 export declare class SimpleRenderer extends BaseRenderer {
-    /** {@link Component.enabled} */
     enabled: boolean;
     /** The HTML container of the THREE.js canvas where the scene is rendered. */
-    container: HTMLElement | null;
+    container: HTMLElement;
     three: THREE.WebGLRenderer;
     protected _canvas: HTMLCanvasElement;
     protected _parameters?: Partial<THREE.WebGLRendererParameters>;
+    protected _resizeObserver: ResizeObserver | null;
     protected onContainerUpdated: Event<HTMLElement>;
-    constructor(components: Components, container?: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
+    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
     /** {@link Updateable.update} */
     update(): void;
     /** {@link Disposable.dispose} */
@@ -28,5 +28,4 @@ export declare class SimpleRenderer extends BaseRenderer {
     private setupRenderer;
     private onContextLost;
     private onContextBack;
-    private updateContainer;
 }

package/dist/core/index.d.ts

@@ -7,3 +7,5 @@ export * from "./Grids";
 export * from "./Clipper";
 export * from "./Materials";
 export * from "./Cullers";
+export * from "./MiniMap";
+export * from "./OrthoPerspectiveCamera";

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

@@ -1,3 +1,4 @@
+import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
 import { Disposable, Component, Event, Components } from "../../core";
 export interface Classification {
@@ -9,13 +10,11 @@ export declare class FragmentClassifier extends Component implements Disposable
     static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
     /** {@link Component.enabled} */
     enabled: boolean;
-    private _groupSystems;
+    list: Classification;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
     constructor(components: Components);
     private onFragmentsDisposed;
-    /** {@link Component.get} */
-    get(): Classification;
     dispose(): void;
     remove(guid: string): void;
     find(filter?: {
@@ -26,5 +25,7 @@ export declare class FragmentClassifier extends Component implements Disposable
     byEntity(group: FRAGS.FragmentsGroup): void;
     byStorey(group: FRAGS.FragmentsGroup): void;
     byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
+    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, _override?: boolean): void;
+    resetColor(items: FRAGS.FragmentIdMap): void;
     private saveItem;
 }

package/dist/fragments/FragmentIfcLoader/src/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./ifc-fragment-settings";
+export * from "./spatial-structure";
 export * from "./civil-reader";
 export * from "./ifc-metadata-reader";

package/dist/fragments/{FragmentIfcStreamer/src/fragment-ifc-stream-converter.d.ts → IfcGeometryTiler/index.d.ts}

@@ -1,8 +1,8 @@
 import * as WEBIFC from "web-ifc";
-import { Components, Disposable, Event, Component } from "../../../core";
-import { IfcStreamingSettings } from "./streaming-settings";
-import { StreamedGeometries, StreamedAsset } from "./base-types";
-export declare class FragmentIfcStreamConverter extends Component implements Disposable {
+import { Components, Disposable, Event, Component } from "../../core";
+import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
+export * from "./src";
+export declare class IfcGeometryTiler extends Component implements Disposable {
     static readonly uuid: "d9999a00-e1f5-4d3f-8cfe-c56e08609764";
     onGeometryStreamed: Event<{
         buffer: Uint8Array;

package/dist/fragments/{FragmentIfcStreamer → IfcGeometryTiler}/src/fragment-props-stream-converter.d.ts

@@ -1,16 +1,16 @@
 import * as WEBIFC from "web-ifc";
-import { Component, Disposable, Event } from "../../../core";
+import { AsyncEvent, Component, Disposable, Event } from "../../../core";
 import { PropertiesStreamingSettings } from "./streaming-settings";
 export declare class FragmentPropsStreamConverter extends Component implements Disposable {
     static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
-    onPropertiesStreamed: Event<{
+    onPropertiesStreamed: AsyncEvent<{
         type: number;
         data: {
             [id: number]: any;
         };
     }>;
-    onProgress: Event<number>;
-    onIndicesStreamed: Event<number[][]>;
+    onProgress: AsyncEvent<number>;
+    onIndicesStreamed: AsyncEvent<number[][]>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<string>;
     enabled: boolean;

package/dist/fragments/{FragmentIfcStreamer → IfcGeometryTiler}/src/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./streaming-settings";
 export * from "./fragment-props-stream-converter";
-export * from "./fragment-ifc-stream-converter";
 export * from "./base-types";

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

@@ -0,0 +1,26 @@
+import * as WEBIFC from "web-ifc";
+import { AsyncEvent, Component, Disposable, Event } from "../../core";
+import { PropertiesStreamingSettings } from "../IfcGeometryTiler";
+export declare class IfcPropertiesTiler extends Component implements Disposable {
+    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
+    onPropertiesStreamed: AsyncEvent<{
+        type: number;
+        data: {
+            [id: number]: any;
+        };
+    }>;
+    onProgress: AsyncEvent<number>;
+    onIndicesStreamed: AsyncEvent<Map<number, Map<number, number[]>>>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    enabled: boolean;
+    settings: PropertiesStreamingSettings;
+    webIfc: WEBIFC.IfcAPI;
+    dispose(): Promise<void>;
+    streamFromBuffer(data: Uint8Array): Promise<void>;
+    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
+    private readIfcFile;
+    private streamIfcFile;
+    private streamAllProperties;
+    private cleanUp;
+}

package/dist/fragments/index.d.ts

@@ -3,5 +3,6 @@ export * from "./FragmentClassifier";
 export * from "./FragmentExploder";
 export * from "./FragmentHider";
 export * from "./FragmentIfcLoader";
-export * from "./FragmentIfcStreamer";
 export * from "./FragmentManager";
+export * from "./IfcGeometryTiler";
+export * from "./IfcPropertiesTiler";

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

@@ -0,0 +1,135 @@
+import * as WEBIFC from "web-ifc";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Disposable, Event, Component, Components } from "../../core";
+import { RelationsMap, ModelsRelationMap, InverseAttributes, InverseAttribute } from "./src/types";
+/**
+ * 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;
+    readonly onRelationsIndexed: Event<{
+        modelID: string;
+        relationsMap: RelationsMap;
+    }>;
+    private _relToAttributesMap;
+    /**
+     * Array of inverse attribute names.
+     * This array is used to define the inverse attributes that the indexer will process and index.
+     */
+    readonly inverseAttributes: InverseAttributes;
+    /**
+     * 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;
+    constructor(components: Components);
+    private onFragmentsDisposed;
+    private getAttributeRels;
+    /**
+     * 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): Promise<RelationsMap>;
+    /**
+     * Processes a given model from a WebIfc API to index its IFC entities relations based on predefined inverse attributes.
+     *
+     * @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.
+     * @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: InverseAttribute): number[] | null;
+    /**
+     * 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;
+    /**
+     * 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;
+}

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

@@ -0,0 +1,3 @@
+export declare const getRelationMap: (properties: Record<string, Record<string, any>>, relationType: number, onElementsFound?: ((relatingID: number, relatedIDs: number[]) => void) | undefined) => {
+    [relatingID: number]: number[];
+};

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

@@ -0,0 +1,4 @@
+export declare const relToAttributesMap: Map<number, {
+    forRelating?: "IsDecomposedBy" | "Decomposes" | "AssociatedTo" | "HasAssociations" | "ClassificationForObjects" | "IsGroupedBy" | "HasAssignments" | "IsDefinedBy" | "DefinesOcurrence" | "IsTypedBy" | "Types" | "Defines" | "ContainedInStructure" | "ContainsElements" | undefined;
+    forRelated?: "IsDecomposedBy" | "Decomposes" | "AssociatedTo" | "HasAssociations" | "ClassificationForObjects" | "IsGroupedBy" | "HasAssignments" | "IsDefinedBy" | "DefinesOcurrence" | "IsTypedBy" | "Types" | "Defines" | "ContainedInStructure" | "ContainsElements" | undefined;
+}>;

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

@@ -0,0 +1,24 @@
+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"
+];
+export type InverseAttribute = InverseAttributes[number];

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";