@thatopen/components 2.4.10 → 3.1.0

package/dist/core/Types/src/component-with-ui.d.ts

@@ -1,18 +0,0 @@
-import { Component } from "./component";
-import { Configurator } from "../../ConfigManager";
-import { Components } from "../../Components";
-export type ComponentUIElement = {
-    name: string;
-    id: string;
-    icon: string;
-    componentID: string;
-    get: (components: Components) => {
-        element: HTMLElement;
-        config?: Configurator;
-        dispose?: () => void;
-    };
-};
-export declare abstract class ComponentWithUI extends Component {
-    abstract name: string;
-    abstract getUI(): ComponentUIElement[];
-}

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

@@ -1,13 +0,0 @@
-import { Base } from "./base";
-/**
- * Components are the building blocks of this library. Components are singleton elements that contain specific functionality. For instance, the Clipper Component can create, delete and handle 3D clipping planes. Components must be unique (they can't be instanced more than once per Components instance), and have a static UUID that identifies them uniquely. The can be accessed globally using the {@link Components} instance.
- */
-export declare abstract class Component extends Base {
-    /**
-     * Whether this component is active or not. The behaviour can vary depending
-     * on the type of component. E.g. a disabled dimension tool will stop creating
-     * dimensions, while a disabled camera will stop moving. A disabled component
-     * will not be updated automatically each frame.
-     */
-    abstract enabled: boolean;
-}

package/dist/core/Types/src/config-types.d.ts

@@ -1,47 +0,0 @@
-import * as THREE from "three";
-export interface BooleanSettingsControl {
-    type: "Boolean";
-    value: boolean;
-}
-export interface ColorSettingsControl {
-    type: "Color";
-    value: THREE.Color;
-}
-export interface TextSettingsControl {
-    type: "Text";
-    value: string;
-}
-export interface NumberSettingControl {
-    type: "Number";
-    interpolable: boolean;
-    min?: number;
-    max?: number;
-    value: number;
-}
-export interface SelectSettingControl {
-    type: "Select";
-    multiple: boolean;
-    options: Set<string>;
-    value: string;
-}
-export interface Vector3SettingControl {
-    type: "Vector3";
-    value: THREE.Vector3;
-}
-export interface TextSetSettingControl {
-    type: "TextSet";
-    value: Set<string>;
-}
-export interface NoControl {
-    type: "None";
-    value: any;
-}
-export type ControlEntry = BooleanSettingsControl | ColorSettingsControl | TextSettingsControl | NumberSettingControl | SelectSettingControl | Vector3SettingControl | TextSetSettingControl | NoControl;
-export interface ControlsSchema {
-    [name: string]: ControlEntry | ControlsSchema;
-}
-export declare class ControlsUtils {
-    static isEntry(item: any): boolean;
-    static copySchema<T extends ControlsSchema = ControlsSchema>(schema: T, copy?: ControlsSchema): T;
-    static copyEntry(controlEntry: ControlEntry): ControlEntry;
-}

package/dist/core/Types/src/data-map.d.ts

@@ -1,73 +0,0 @@
-import { Event } from "./event";
-/**
- * A class that extends the built-in Map class and provides additional events for item set, update, delete, and clear operations.
- *
- * @template K - The type of keys in the map.
- * @template V - The type of values in the map.
- */
-export declare class DataMap<K, V> extends Map<K, V> {
-    /**
-     * An event triggered when a new item is set in the map.
-     */
-    readonly onItemSet: Event<{
-        key: K;
-        value: V;
-    }>;
-    /**
-     * An event triggered when an existing item in the map is updated.
-     */
-    readonly onItemUpdated: Event<{
-        key: K;
-        value: V;
-    }>;
-    /**
-     * An event triggered when an item is deleted from the map.
-     */
-    readonly onItemDeleted: Event<K>;
-    /**
-     * An event triggered when the map is cleared.
-     */
-    readonly onCleared: Event<unknown>;
-    /**
-     * Constructs a new DataMap instance.
-     *
-     * @param iterable - An iterable object containing key-value pairs to populate the map.
-     */
-    constructor(iterable?: Iterable<readonly [K, V]> | null | undefined);
-    /**
-     * Clears the map and triggers the onCleared event.
-     */
-    clear(): void;
-    /**
-     * Sets the value for the specified key in the map.
-     * If the item is new, then onItemSet is triggered.
-     * If the item is already in the map, then onItemUpdated is triggered.
-     *
-     * @param key - The key of the item to set.
-     * @param value - The value of the item to set.
-     * @returns The DataMap instance.
-     */
-    set(key: K, value: V): this;
-    /**
-     * A function that acts as a guard for adding items to the set.
-     * It determines whether a given value should be allowed to be added to the set.
-     *
-     * @param key - The key of the entry to be checked against the guard.
-     * @param value - The value of the entry to be checked against the guard.
-     * @returns A boolean indicating whether the value should be allowed to be added to the set.
-     *          By default, this function always returns true, allowing all values to be added.
-     *          You can override this behavior by providing a custom implementation.
-     */
-    guard: (key: K, value: V) => boolean;
-    /**
-     * Deletes the specified key from the map and triggers the onItemDeleted event if the key was found.
-     *
-     * @param key - The key of the item to delete.
-     * @returns True if the key was found and deleted; otherwise, false.
-     */
-    delete(key: K): boolean;
-    /**
-     * Clears the map and resets the events.
-     */
-    dispose(): void;
-}

package/dist/core/Types/src/data-set.d.ts

@@ -1,58 +0,0 @@
-import { Event } from "./event";
-/**
- * A class that extends the built-in Set class and provides additional functionality. It triggers events when items are added, deleted, or the set is cleared.
- *
- * @template T - The type of elements in the set.
- */
-export declare class DataSet<T> extends Set<T> {
-    /**
-     * An event that is triggered when a new item is added to the set.
-     */
-    readonly onItemAdded: Event<T>;
-    /**
-     * An event that is triggered when an item is deleted from the set.
-     */
-    readonly onItemDeleted: Event<unknown>;
-    /**
-     * An event that is triggered when the set is cleared.
-     */
-    readonly onCleared: Event<unknown>;
-    /**
-     * Constructs a new instance of the DataSet class.
-     *
-     * @param iterable - An optional iterable object to initialize the set with.
-     */
-    constructor(iterable?: Iterable<T> | null);
-    /**
-     * Clears the set and triggers the onCleared event.
-     */
-    clear(): void;
-    /**
-     * Adds one or multiple values to the set and triggers the onItemAdded event per each.
-     *
-     * @param value - The value to add to the set.
-     * @returns - The set instance.
-     */
-    add(...value: T[]): this;
-    /**
-     * A function that acts as a guard for adding items to the set.
-     * It determines whether a given value should be allowed to be added to the set.
-     *
-     * @param value - The value to be checked against the guard.
-     * @returns A boolean indicating whether the value should be allowed to be added to the set.
-     *          By default, this function always returns true, allowing all values to be added.
-     *          You can override this behavior by providing a custom implementation.
-     */
-    guard: (value: T) => boolean;
-    /**
-     * Deletes a value from the set and triggers the onItemDeleted event.
-     *
-     * @param value - The value to delete from the set.
-     * @returns - True if the value was successfully deleted, false otherwise.
-     */
-    delete(value: T): boolean;
-    /**
-     * Clears the set and resets the onItemAdded, onItemDeleted, and onCleared events.
-     */
-    dispose(): void;
-}

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

@@ -1,30 +0,0 @@
-import { Event } from "./event";
-import { AsyncEvent } from "./async-event";
-/**
- * Simple class to easily toggle and reset event lists.
- */
-export declare class EventManager {
-    /**
-     * The list of events managed by this instance.
-     */
-    list: Set<Event<any> | AsyncEvent<any>>;
-    /**
-     * Adds events to this manager.
-     * @param events the events to add.
-     */
-    add(events: Iterable<Event<any> | AsyncEvent<any>>): void;
-    /**
-     * Removes events from this manager.
-     * @param events the events to remove.
-     */
-    remove(events: Iterable<Event<any> | AsyncEvent<any>>): void;
-    /**
-     * Sets all the events managed by this instance as enabled or disabled.
-     * @param active whether to turn on or off the events.
-     */
-    set(active: boolean): void;
-    /**
-     * Resets all the events managed by this instance.
-     */
-    reset(): void;
-}

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

@@ -1,32 +0,0 @@
-/**
- * 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 Event<T> {
-    /**
-     * Whether this event is active or not. If not, it won't trigger.
-     */
-    enabled: boolean;
-    /**
-     * Add a callback to this event instance.
-     * @param handler - the callback to be added to this event.
-     */
-    add(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
-    /**
-     * Removes a callback from this event instance.
-     * @param handler - the callback to be removed from this event.
-     */
-    remove(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
-    /** Triggers all the callbacks assigned to this event. */
-    trigger: (data?: T) => void;
-    /** Gets rid of all the suscribed events. */
-    reset(): void;
-    private handlers;
-}

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

@@ -1,15 +0,0 @@
-export * from "./event";
-export * from "./async-event";
-export * from "./interfaces";
-export * from "./component";
-export * from "./base";
-export * from "./base-world-item";
-export * from "./base-camera";
-export * from "./base-renderer";
-export * from "./base-scene";
-export * from "./world";
-export * from "./data-set";
-export * from "./data-map";
-export * from "./component-with-ui";
-export * from "./config-types";
-export * from "./event-manager";

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

@@ -1,117 +0,0 @@
-import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { Event } from "./event";
-import { EventManager } from "./event-manager";
-/**
- * Whether this component has to be manually destroyed once you are done with it to prevent [memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects). This also ensures that the DOM events created by that component will be cleaned up.
- */
-export interface Disposable {
-    /**
-     * Destroys the object from memory to prevent a
-     * [memory leak](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
-     */
-    dispose: () => void | Promise<void>;
-    /** Fired after the tool has been disposed.  */
-    readonly onDisposed: Event<any>;
-}
-/**
- * Whether the geometric representation of this component can be hidden or shown in the [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
- */
-export interface Hideable {
-    /**
-     * Whether the geometric representation of this component is
-     * currently visible or not in the
-     * [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
-     */
-    visible: boolean;
-}
-/**
- * Whether this component can be resized. The meaning of this can vary depending on the component: resizing a [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer) component could mean changing its resolution, whereas resizing a [Mesh](https://threejs.org/docs/#api/en/objects/Mesh) would change its scale.
- */
-export interface Resizeable {
-    /**
-     * Sets size of this component (e.g. the resolution of a
-     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
-     * component.
-     */
-    resize: (size?: THREE.Vector2) => void;
-    /** Event that fires when the component has been resized. */
-    onResize: Event<THREE.Vector2>;
-    /**
-     * Gets the current size of this component (e.g. the resolution of a
-     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
-     * component.
-     */
-    getSize: () => THREE.Vector2;
-}
-/** Whether this component should be updated each frame. */
-export interface Updateable {
-    /** Actions that should be executed after updating the component. */
-    onAfterUpdate: Event<any>;
-    /** Actions that should be executed before updating the component. */
-    onBeforeUpdate: Event<any>;
-    /**
-     * 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;
-}
-/** Basic type to describe the progress of any kind of process. */
-export interface Progress {
-    /** The amount of things that have been done already. */
-    current: number;
-    /** The total amount of things to be done by the process. */
-    total: number;
-}
-/**
- * Whether this component supports create and destroy operations. This generally applies for components that work with instances, such as clipping planes or dimensions.
- */
-export interface Createable {
-    /** Creates a new instance of an element (e.g. a new Dimension). */
-    create: (data: any) => void;
-    /**
-     * Finish the creation process of the component, successfully creating an
-     * instance of whatever the component creates.
-     */
-    endCreation?: (data: any) => void;
-    /**
-     * Cancels the creation process of the component, going back to the state
-     * before starting to create.
-     */
-    cancelCreation?: (data: any) => void;
-    /** Deletes an existing instance of an element (e.g. a Dimension). */
-    delete: (data: any) => void;
-}
-/**
- * Whether this component supports to be configured.
- */
-export interface Configurable<T, U> {
-    /** Wether this components has been already configured. */
-    isSetup: boolean;
-    /** Use the provided configuration to set up the tool. */
-    setup: (config?: Partial<U>) => void | Promise<void>;
-    /** Fired after successfully calling {@link Configurable.setup()}  */
-    readonly onSetup: Event<any>;
-    /** Object holding the tool configuration. You can edit this directly to change the object.
-     */
-    config: Required<T>;
-}
-/**
- * Whether a camera uses the Camera Controls library.
- */
-export interface CameraControllable {
-    /**
-     * An instance of CameraControls that provides camera control functionalities.
-     * This instance is used to manipulate the camera.
-     */
-    controls: CameraControls;
-}
-/**
- * Whether it has events or not.
- */
-export interface Eventable {
-    /**
-     * The object in charge of managing all the events.
-     */
-    eventManager: EventManager;
-}

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

@@ -1,34 +0,0 @@
-import * as THREE from "three";
-import { BaseScene } from "./base-scene";
-import { BaseCamera } from "./base-camera";
-import { BaseRenderer } from "./base-renderer";
-import { Updateable, Disposable } from "./interfaces";
-/**
- * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
- */
-export interface World extends Disposable, Updateable {
-    /**
-     * A set of meshes present in the world. This is taken into account for operations like raycasting.
-     */
-    meshes: Set<THREE.Mesh>;
-    /**
-     * The base scene of the world.
-     */
-    scene: BaseScene;
-    /**
-     * The base camera of the world.
-     */
-    camera: BaseCamera;
-    /**
-     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
-     */
-    renderer: BaseRenderer | null;
-    /**
-     * A unique identifier for the world.
-     */
-    uuid: string;
-    /**
-     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
-     */
-    isDisposing: boolean;
-}

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

@@ -1,38 +0,0 @@
-import { World, Component, Disposable, Event, DataMap, Configurable } from "../Types";
-import { Components } from "../Components";
-import { BCFViewpoint, Viewpoint } from "./src";
-import { ViewpointsConfigManager, ViewpointsConfig } from "./src/viewpoints-config";
-export * from "./src";
-export declare class Viewpoints extends Component implements Disposable, Configurable<ViewpointsConfigManager, ViewpointsConfig> {
-    static readonly uuid: "ee867824-a796-408d-8aa0-4e5962a83c66";
-    enabled: boolean;
-    /**
-     * A DataMap that stores Viewpoint instances, indexed by their unique identifiers (guid).
-     * This map is used to manage and retrieve Viewpoint instances within the Viewpoints component.
-     */
-    readonly list: DataMap<string, Viewpoint>;
-    /**
-     * Creates a new Viewpoint instance and adds it to the list.
-     *
-     * @param world - The world in which the Viewpoint will be created.
-     * @param data - Optional partial data for the Viewpoint. If not provided, default data will be used.
-     *
-     * @returns The newly created Viewpoint instance.
-     */
-    create(world: World, data?: Partial<BCFViewpoint>): Viewpoint;
-    constructor(components: Components);
-    isSetup: boolean;
-    setup(): void;
-    onSetup: Event<unknown>;
-    config: ViewpointsConfigManager;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Disposes of the Viewpoints component and its associated resources.
-     *
-     * This method is responsible for cleaning up any resources held by the Viewpoints component,
-     * such as disposing of the DataMap of Viewpoint instances and triggering and resetting the
-     * onDisposed event.
-     */
-    dispose(): void;
-}

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

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

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

@@ -1,36 +0,0 @@
-import { SimplePlane } from "../../Clipper";
-import { DataSet } from "../../Types";
-export interface ViewpointCamera {
-    direction: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    position: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    aspectRatio: number;
-}
-export interface ViewpointPerspectiveCamera extends ViewpointCamera {
-    fov: number;
-}
-export interface ViewpointOrthographicCamera extends ViewpointCamera {
-    viewToWorldScale: number;
-}
-/**
- * Represents a viewpoint in a BCF file.
- */
-export interface BCFViewpoint {
-    title?: string;
-    guid: string;
-    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
-    selectionComponents: Iterable<string>;
-    exceptionComponents: Iterable<string>;
-    clippingPlanes: DataSet<SimplePlane>;
-    spacesVisible: boolean;
-    spaceBoundariesVisible: boolean;
-    openingsVisible: boolean;
-    defaultVisibility: boolean;
-}