@thatopen/components 2.0.0-alpha.0 → 2.0.0-alpha.10

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

@@ -40,10 +40,10 @@ 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;
+    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/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/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/MiniMap/index.d.ts

@@ -0,0 +1,15 @@
+import { Component, Components, Disposable, Updateable, World, Event } from "../../core";
+import { MiniMap } from "./src";
+export declare class MiniMaps extends Component implements Updateable, Disposable {
+    static readonly uuid: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
+    readonly onAfterUpdate: Event<unknown>;
+    readonly onBeforeUpdate: Event<unknown>;
+    readonly onDisposed: Event<unknown>;
+    enabled: boolean;
+    list: Map<string, MiniMap>;
+    constructor(components: Components);
+    create(world: World): MiniMap;
+    delete(id: string): void;
+    dispose(): void | Promise<void>;
+    update(): void;
+}

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

@@ -0,0 +1,34 @@
+import * as THREE from "three";
+import { Event, Resizeable, Updateable, Disposable, World } from "../../../core";
+export declare class MiniMap implements Resizeable, Updateable, Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    readonly onAfterUpdate: Event<unknown>;
+    readonly onBeforeUpdate: Event<unknown>;
+    readonly onResize: Event<THREE.Vector2>;
+    frontOffset: number;
+    overrideMaterial: THREE.MeshDepthMaterial;
+    backgroundColor: THREE.Color;
+    renderer: THREE.WebGLRenderer;
+    enabled: boolean;
+    world: World;
+    private _lockRotation;
+    private _camera;
+    private _plane;
+    private _size;
+    private _tempVector1;
+    private _tempVector2;
+    private _tempTarget;
+    private readonly down;
+    get lockRotation(): boolean;
+    set lockRotation(active: boolean);
+    get zoom(): number;
+    set zoom(value: number);
+    constructor(world: World);
+    dispose(): void;
+    get(): THREE.OrthographicCamera;
+    update(): void;
+    getSize(): THREE.Vector2;
+    resize(size?: THREE.Vector2): void;
+    private updatePlanes;
+}

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

@@ -0,0 +1,50 @@
+import * as THREE from "three";
+import { Components } from "../../core/Components";
+import { SimpleCamera } from "../../core";
+import { NavigationMode, NavModeID, ProjectionManager } from "./src";
+export * from "./src";
+/**
+ * A flexible camera that uses
+ * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to
+ * easily control the camera in 2D and 3D. It supports multiple navigation
+ * modes, such as 2D floor plan navigation, first person and 3D orbit.
+ */
+export declare class OrthoPerspectiveCamera extends SimpleCamera {
+    /**
+     * The current {@link NavigationMode}.
+     */
+    mode: NavigationMode;
+    readonly projection: ProjectionManager;
+    readonly threeOrtho: THREE.OrthographicCamera;
+    protected readonly _userInputButtons: any;
+    protected readonly _frustumSize = 50;
+    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
+    get current(): THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Sets a new {@link NavigationMode} and disables the previous one.
+     *
+     * @param mode - The {@link NavigationMode} to set.
+     */
+    set(mode: NavModeID): void;
+    /**
+     * Make the camera view fit all the specified meshes.
+     *
+     * @param meshes the meshes to fit. If it is not defined, it will
+     * evaluate {@link Components.meshes}.
+     * @param offset the distance to the fit object
+     */
+    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
+    /**
+     * Allows or prevents all user input.
+     *
+     * @param active - whether to enable or disable user inputs.
+     */
+    setUserInput(active: boolean): void;
+    private disableUserInput;
+    private enableUserInput;
+    private newOrthoCamera;
+    private setOrthoCameraAspect;
+}

package/dist/core/OrthoPerspectiveCamera/src/first-person-mode.d.ts

@@ -0,0 +1,16 @@
+import { NavigationMode } from "./types";
+/**
+ * A {@link NavigationMode} that allows first person navigation,
+ * simulating FPS video games.
+ */
+export declare class FirstPersonMode implements NavigationMode {
+    private camera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "FirstPerson";
+    constructor(camera: any);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private setupFirstPersonCamera;
+}

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

@@ -0,0 +1,5 @@
+export * from "./first-person-mode";
+export * from "./orbit-mode";
+export * from "./plan-mode";
+export * from "./projections";
+export * from "./types";

package/dist/core/OrthoPerspectiveCamera/src/orbit-mode.d.ts

@@ -0,0 +1,16 @@
+import { NavigationMode } from "./types";
+/**
+ * A {@link NavigationMode} that allows 3D navigation and panning
+ * like in many 3D and CAD softwares.
+ */
+export declare class OrbitMode implements NavigationMode {
+    camera: any;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "Orbit";
+    constructor(camera: any);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private activateOrbitControls;
+}

package/dist/core/OrthoPerspectiveCamera/src/plan-mode.d.ts

@@ -0,0 +1,20 @@
+import { NavigationMode } from "./types";
+/**
+ * A {@link NavigationMode} that allows to navigate floorplans in 2D,
+ * like many BIM tools.
+ */
+export declare class PlanMode implements NavigationMode {
+    private camera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "Plan";
+    private mouseAction1?;
+    private mouseAction2?;
+    private mouseInitialized;
+    private readonly defaultAzimuthSpeed;
+    private readonly defaultPolarSpeed;
+    constructor(camera: any);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+}

package/dist/core/OrthoPerspectiveCamera/src/projections.d.ts

@@ -0,0 +1,37 @@
+import * as THREE from "three";
+import { CameraProjection } from "./types";
+import { Event } from "../../../core";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ */
+export declare class ProjectionManager {
+    /**
+     * Event that fires when the {@link CameraProjection} changes.
+     */
+    readonly onChanged: Event<THREE.Camera>;
+    current: CameraProjection;
+    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    private _component;
+    private _previousDistance;
+    /** Match Ortho zoom with Perspective distance when changing projection mode */
+    matchOrthoDistanceEnabled: boolean;
+    constructor(camera: OrthoPerspectiveCamera);
+    /**
+     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+     *
+     * @param projection - the new projection to set. If it is the current projection,
+     * it will have no effect.
+     */
+    set(projection: CameraProjection): Promise<void>;
+    /**
+     * Changes the current {@link CameraProjection} from Ortographic to Perspective
+     * and vice versa.
+     */
+    toggle(): Promise<void>;
+    private setOrthoCamera;
+    private getDims;
+    private setupOrthoCamera;
+    private getDistance;
+    private setPerspectiveCamera;
+}

package/dist/core/OrthoPerspectiveCamera/src/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The projection system of the camera.
+ */
+export type CameraProjection = "Perspective" | "Orthographic";
+/**
+ * The extensible list of supported navigation modes.
+ */
+export type NavModeID = "Orbit" | "FirstPerson" | "Plan";
+/**
+ * An object that determines the behavior of the camera controls
+ * and the user input (e.g. 2D floor plan mode, first person mode, etc).
+ */
+export interface NavigationMode {
+    /** The unique ID of this navigation mode. */
+    id: NavModeID;
+    /**
+     * Enable or disable this navigation mode.
+     * When a new navigation mode is enabled, the previous navigation mode
+     * must be disabled.
+     *
+     * @param active - whether to enable or disable this mode.
+     * @param options - any additional data required to enable or disable it.
+     * */
+    set: (active: boolean, options?: any) => void;
+    /** Whether this navigation mode is active or not. */
+    enabled: boolean;
+}

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/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/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/{FragmentBoundingBox → BoundingBoxes}/index.d.ts

@@ -1,12 +1,12 @@
 import * as THREE from "three";
-import * as FRAGS from "bim-fragment";
-import { FragmentsGroup } from "bim-fragment";
+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.
  */
-export declare class FragmentBoundingBox extends Component implements Disposable {
+export declare class BoundingBoxes extends Component implements Disposable {
     static readonly uuid: "d1444724-dba6-4cdd-a0c7-68ee1450d166";
     /** {@link Component.enabled} */
     enabled: boolean;
@@ -31,6 +31,6 @@ export declare class FragmentBoundingBox extends Component implements Disposable
     getMesh(): THREE.Mesh<THREE.BoxGeometry, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
     reset(): void;
     add(group: FragmentsGroup): void;
-    addMesh(mesh: THREE.InstancedMesh | THREE.Mesh | FRAGS.CurveMesh): void;
+    addMesh(mesh: THREE.InstancedMesh | THREE.Mesh | FRAGS.CurveMesh, itemIDs?: Iterable<number>): void;
     private static getFragmentBounds;
 }

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

@@ -1,4 +1,5 @@
-import * as FRAGS from "bim-fragment";
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
 import { Disposable, Component, Event, Components } from "../../core";
 export interface Classification {
     [system: string]: {
@@ -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/FragmentHider/index.d.ts

@@ -0,0 +1,10 @@
+import * as FRAGS from "@thatopen/fragments";
+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/FragmentIfcLoader/index.d.ts

@@ -1,10 +1,9 @@
 import * as WEBIFC from "web-ifc";
-import * as FRAGS from "bim-fragment";
+import * as FRAGS from "@thatopen/fragments";
 import { IfcFragmentSettings } from "./src";
 import { Component, Components, Event, Disposable } from "../../core";
 export declare class FragmentIfcLoader extends Component implements Disposable {
     static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
-    readonly onIfcLoaded: Event<FRAGS.FragmentsGroup>;
     readonly onIfcStartedLoading: Event<void>;
     readonly onSetup: Event<void>;
     /** {@link Disposable.onDisposed} */

package/dist/fragments/FragmentIfcLoader/src/civil-reader.d.ts

@@ -1,6 +1,6 @@
 import * as THREE from "three";
 import * as WEBIFC from "web-ifc";
-import * as FRAGS from "bim-fragment";
+import * as FRAGS from "@thatopen/fragments";
 export declare class CivilReader {
     defLineMat: THREE.LineBasicMaterial;
     read(webIfc: WEBIFC.IfcAPI): {

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/FragmentManager/index.d.ts

@@ -1,4 +1,4 @@
-import { Fragment, FragmentsGroup } from "bim-fragment";
+import { Fragment, FragmentsGroup } from "@thatopen/fragments";
 import * as THREE from "three";
 import { Component, Components, Event, Disposable } from "../../core";
 /**

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

@@ -1,5 +1,8 @@
-export * from "./FragmentBoundingBox";
+export * from "./BoundingBoxes";
 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/IfcJsonExporter/index.d.ts

@@ -1,5 +1,5 @@
 import * as WEBIFC from "web-ifc";
-import * as FRAG from "bim-fragment";
+import * as FRAG from "@thatopen/fragments";
 /**
  * Object to export all the properties from an IFC to a JS object.
  */