vim-web 0.3.23 → 0.3.25

package/dist/types/react-viewer/helpers/inputs.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @module viw-webgl-react
+ */
+import * as VIM from '../../webgl-viewer/index';
+import { SideState } from '../sidePanel/sideState';
+import { Isolation } from './isolation';
+import { ComponentCamera } from './camera';
+/**
+ * Custom viewer input scheme for the vim component
+ */
+export declare class ComponentInputs implements VIM.InputScheme {
+    private _viewer;
+    private _camera;
+    private _default;
+    private _isolation;
+    private _sideState;
+    private _help;
+    constructor(viewer: VIM.Viewer, camera: ComponentCamera, isolation: Isolation, sideState: SideState);
+    private _getSelection;
+    onMainAction(hit: VIM.InputAction): void;
+    onIdleAction(hit: VIM.InputAction): void;
+    onKeyAction(key: number): boolean;
+}

package/dist/types/react-viewer/helpers/isolation.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @module viw-webgl-react
+ */
+import * as VIM from '../../webgl-viewer/index';
+import { ComponentSettings } from '../settings/settings';
+import { ComponentCamera } from './camera';
+/**
+ * Manages the isolation mechanic in the vim component.
+ */
+export declare class Isolation {
+    private _viewer;
+    private _settings;
+    private _isolation;
+    private _lastIsolation;
+    private _camera;
+    private _references;
+    private _onChanged;
+    /** Signal dispatched when the isolation set changes. */
+    get onChanged(): import("ste-simple-events").ISimpleEvent<string>;
+    constructor(viewer: VIM.Viewer, camera: ComponentCamera, settings: ComponentSettings);
+    /**
+     * Applies relevant settings to isolation.
+     * @param settings The settings to be applied to isolation.
+     */
+    applySettings(settings: ComponentSettings): void;
+    /**
+     * Sets the reference objects for a given VIM.
+     * @param vim The VIM for which reference objects are being set.
+     * @param reference An array of reference objects or the string 'always' to indicate permanent reference.
+     */
+    setReference(vim: VIM.Vim, reference: VIM.Object3D[] | 'always'): void;
+    /**
+     * Retrieves the reference objects set for a given VIM.
+     * @param vim The VIM for which reference objects are being retrieved.
+     * @returns The reference objects set for the specified VIM.
+     */
+    getReference(vim: VIM.Vim): Set<VIM.Object3D> | "always";
+    /**
+     * Clears all reference objects set for VIMs.
+     */
+    clearReferences(): void;
+    /**
+     * Returns true if there are currently objects isolated.
+     * @returns True if there are currently objects isolated; otherwise, false.
+     */
+    any(): boolean;
+    /**
+     * Returns the current array of isolated objects.
+     * @returns The array of objects currently isolated, or undefined if no objects are isolated.
+     */
+    current(): VIM.Object3D[];
+    /**
+     * Isolates the objects in the given array and shows the rest as ghost.
+     * @param objects An array of objects to isolate.
+     * @param source The source of isolation.
+     * @returns True if isolation occurs; otherwise, false.
+     */
+    isolate(objects: VIM.Object3D[], source: string): boolean;
+    /**
+     * Toggles current isolation based on selection.
+     * @param source The source of isolation.
+     */
+    toggleIsolation(source: string): void;
+    /**
+     * Removes the given objects from the isolation set.
+     * @param objects An array of objects to be removed from isolation.
+     * @param source The source of the removal operation.
+     */
+    hide(objects: VIM.Object3D[], source: string): void;
+    /**
+     * Adds the given objects to the isolation set.
+     * @param objects An array of objects to be added to isolation.
+     * @param source The source of the addition operation.
+     */
+    show(objects: VIM.Object3D[], source: string): void;
+    /**
+     * Clears the current isolation.
+     * @param source The source of the isolation clearing operation.
+     */
+    clear(source: string): void;
+    /**
+     * Show all objects and quit isolation mode.
+     */
+    private _showAll;
+    getMaterial(settings: ComponentSettings, isolate: boolean): VIM.THREE.Material;
+    private _isolate;
+}

package/dist/types/react-viewer/helpers/loadRequest.d.ts

@@ -0,0 +1,29 @@
+import * as VIM from '../../webgl-viewer/index';
+import { LoadingError } from '../webgl/webglLoading';
+type RequestCallbacks = {
+    onProgress: (p: VIM.IProgressLogs) => void;
+    onError: (e: LoadingError) => void;
+    onDone: () => void;
+};
+/**
+ * Class to handle loading a request.
+ */
+export declare class LoadRequest {
+    readonly source: any;
+    private _callbacks;
+    private _request;
+    private _progress;
+    private _progressPromise;
+    private _isDone;
+    private _completionPromise;
+    constructor(callbacks: RequestCallbacks, source: VIM.RequestSource, settings: VIM.VimPartialSettings);
+    private startRequest;
+    private onProgress;
+    private onSuccess;
+    private onError;
+    private end;
+    getProgress(): AsyncGenerator<VIM.IProgressLogs, void, void>;
+    getResult(): Promise<import("../../webgl-viewer/utils/requestResult").RequestResult<VIM.Vim>>;
+    abort(): void;
+}
+export {};

package/dist/types/react-viewer/helpers/requestResult.d.ts

@@ -0,0 +1,13 @@
+export declare class SuccessResult<T> {
+    result: T;
+    constructor(result: T);
+    isSuccess(): true;
+    isError(): false;
+}
+export declare class ErrorResult {
+    error: string;
+    constructor(error: string);
+    isSuccess(): false;
+    isError(): this is ErrorResult;
+}
+export type RequestResult<T> = SuccessResult<T> | ErrorResult;

package/dist/types/react-viewer/helpers/utils.d.ts

@@ -0,0 +1,7 @@
+import { UserBoolean } from '../settings/settings';
+export declare function whenTrue(value: UserBoolean | boolean, element: JSX.Element): JSX.Element;
+export declare function whenFalse(value: UserBoolean | boolean, element: JSX.Element): JSX.Element;
+export declare function whenAllTrue(value: (UserBoolean | boolean)[], element: JSX.Element): JSX.Element;
+export declare function whenAllFalse(value: (UserBoolean | boolean)[], element: JSX.Element): JSX.Element;
+export declare function whenSomeTrue(value: (UserBoolean | boolean)[], element: JSX.Element): JSX.Element;
+export declare function whenSomeFalse(value: (UserBoolean | boolean)[], element: JSX.Element): JSX.Element;

package/dist/types/react-viewer/panels/axesPanel.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @module viw-webgl-react
+ */
+import React from 'react';
+import { ComponentCamera } from '../helpers/camera';
+import { SettingsState } from '../settings/settingsState';
+import { VIM } from '../webgl/webglComponent';
+/**
+ * Memoized version of the AxesPanelMemo.
+ */
+export declare const AxesPanelMemo: React.MemoExoticComponent<typeof AxesPanel>;
+/**
+ * JSX Component for axes gizmo.
+ */
+declare function AxesPanel(props: {
+    viewer: VIM.Viewer;
+    camera: ComponentCamera;
+    settings: SettingsState;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/react-viewer/panels/contextMenu.d.ts

@@ -0,0 +1,75 @@
+/**
+ * @module viw-webgl-react
+ */
+import React from 'react';
+import { WebglViewer } from '../../vimWebIndex';
+import { Isolation } from '../helpers/isolation';
+import { ComponentCamera } from '../helpers/camera';
+import { TreeActionRef } from '../bim/bimTree';
+import { ModalRef } from './modal';
+export declare const VIM_CONTEXT_MENU_ID = "vim-context-menu-id";
+export type ClickCallback = React.MouseEvent<HTMLDivElement, MouseEvent>;
+export declare function showContextMenu(position: {
+    x: number;
+    y: number;
+} | undefined): void;
+/**
+ * Current list of context menu item ids. Used to find and replace items when customizing the context menu.
+ */
+export declare const contextMenuElementIds: {
+    showControls: string;
+    dividerCamera: string;
+    resetCamera: string;
+    zoomToFit: string;
+    dividerSelection: string;
+    isolateSelection: string;
+    selectSimilar: string;
+    hideObject: string;
+    showObject: string;
+    clearSelection: string;
+    showAll: string;
+    dividerMeasure: string;
+    deleteMeasurement: string;
+    dividerSection: string;
+    ignoreSection: string;
+    resetSection: string;
+    fitSectionToSelection: string;
+};
+/**
+ * Represents a button in the context menu. It can't be clicked triggering given action.
+ */
+export interface IContextMenuButton {
+    id: string;
+    label: string;
+    keyboard: string;
+    action: (e: ClickCallback) => void;
+    enabled: boolean;
+}
+/**
+ * Represents a divider in the context menu. It can't be clicked.
+ */
+export interface IContextMenuDivider {
+    id: string;
+    enabled: boolean;
+}
+export type ContextMenuElement = IContextMenuButton | IContextMenuDivider;
+/**
+ * A map function that changes the context menu.
+ */
+export type ContextMenuCustomization = (e: ContextMenuElement[]) => ContextMenuElement[];
+/**
+ * Memoized version of VimContextMenu.
+ */
+export declare const VimContextMenuMemo: React.MemoExoticComponent<typeof VimContextMenu>;
+/**
+ * Context menu component definition according to current state.
+ */
+export declare function VimContextMenu(props: {
+    viewer: WebglViewer.Viewer;
+    camera: ComponentCamera;
+    modal: ModalRef;
+    isolation: Isolation;
+    selection: WebglViewer.Object3D[];
+    customization?: (e: ContextMenuElement[]) => ContextMenuElement[];
+    treeRef: React.MutableRefObject<TreeActionRef | undefined>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/react-viewer/panels/help.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @module viw-webgl-react
+ */
+export type HelpProps = {
+    link: boolean;
+};
+export type HelpPropsTyped = HelpProps & {
+    type: 'help';
+};
+/**
+ * JSX Component for help page.
+ */
+export declare function MenuHelp(props: {
+    value: HelpProps;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/react-viewer/panels/icons.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @module icons
+ */
+/**
+ * Common Icon Options.
+ */
+export type IconOptions = {
+    height: number | string;
+    width: number | string;
+    fill: string;
+    className?: string;
+};
+export declare function settings({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function help({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function trash({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function checkmark({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function undo({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function close({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function home({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function fullsScreen({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function minimize({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function treeView({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function more({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function collapse({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function arrowLeft({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function fullArrowLeft({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function visible({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function hidden({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function orbit({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function look({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function perspective({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function orthographic({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function camera({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function pan({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function zoom({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function frameRect({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function frameSelection({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function toggleIsolation({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function measure({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function sectionBox({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function sectionBoxClip({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function sectionBoxIgnore({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function sectionBoxReset({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function sectionBoxShrink({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function ghost({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function ghostDead({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;

package/dist/types/react-viewer/panels/loadingBox.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @module viw-webgl-react
+ */
+export type ProgressMode = '%' | 'bytes';
+/**
+ * Interface for message information displayed in the LoadingBox.
+ * @property message - Optional main message text.
+ * @property info - Optional additional information or tooltip text.
+ * @property progress - The progress of an operation.
+ */
+export type LoadingBoxProps = {
+    message?: string;
+    progress?: number;
+    mode?: ProgressMode;
+};
+export type LoadingBoxPropsTyped = LoadingBoxProps & {
+    type: 'loading';
+};
+/**
+ * LoadingBox component that displays a loading message or other messages.
+ * @param props - Component props containing optional content.
+ * @returns The LoadingBox component or null if no content is provided.
+ */
+export declare function LoadingBox(props: {
+    content: LoadingBoxProps;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/react-viewer/panels/logo.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @module viw-webgl-react
+ */
+import React from 'react';
+export declare const LogoMemo: React.MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;

package/dist/types/react-viewer/panels/messageBox.d.ts

@@ -0,0 +1,14 @@
+export type MessageBoxProps = {
+    title: string;
+    body: string | JSX.Element;
+    footer?: string | JSX.Element;
+    canClose: boolean;
+    onClose?: () => void;
+};
+export type MessageBoxPropsTyped = MessageBoxProps & {
+    type: 'message';
+};
+export declare function MessageBox(props: {
+    value: MessageBoxProps;
+}): import("react/jsx-runtime").JSX.Element;
+export default MessageBox;

package/dist/types/react-viewer/panels/modal.d.ts

@@ -0,0 +1,18 @@
+import { MessageBoxProps, MessageBoxPropsTyped } from './messageBox';
+import { LoadingBoxProps, LoadingBoxPropsTyped } from './loadingBox';
+import { HelpProps, HelpPropsTyped } from './help';
+export type ModalProps = MessageBoxProps | LoadingBoxProps | HelpProps;
+export type ModalPropsTyped = (MessageBoxPropsTyped | LoadingBoxPropsTyped | HelpPropsTyped) & {
+    canClose: boolean;
+    onClose?: () => void;
+};
+export type ModalRef = {
+    current: ModalPropsTyped | undefined;
+    loading(content: LoadingBoxProps | undefined): void;
+    message(content: MessageBoxProps | undefined): void;
+    help(show: boolean): void;
+};
+export declare function useModal(canFollowLinks: boolean): ModalRef;
+export declare function Modal(props: {
+    state: ModalRef;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/react-viewer/panels/overlay.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @module viw-webgl-react
+ */
+/** This overlay is designed to go over the viewer canvas to intercept and dispatch events to the viewer canvas.
+ * The point is that quickly finding a ui hit avoids the browser hit detection to search through all elements.
+ * When the tree view is open with 10+k elements this increases general fps significantly.
+ */
+export declare function Overlay(props: {
+    canvas: HTMLCanvasElement;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/react-viewer/panels/performance.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module viw-webgl-react
+ */
+/**
+ * Adds popular performance gizmo from package stat-js
+ */
+export declare function addPerformanceCounter(parent: HTMLDivElement): void;

package/dist/types/react-viewer/panels/toast.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @module viw-webgl-react
+ */
+import React from 'react';
+import * as VIM from '../../webgl-viewer/index';
+import { SideState } from '../sidePanel/sideState';
+export type ToastConfigSpeed = {
+    visible: boolean;
+    speed: number;
+};
+/**
+ * Memoized version of MenuToast.
+ */
+export declare const MenuToastMemo: React.MemoExoticComponent<typeof MenuToast>;
+/**
+ * Toast jsx component that briefly shows up when camera speed changes.
+ */
+declare function MenuToast(props: {
+    viewer: VIM.Viewer;
+    side: SideState;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/react-viewer/reactViewerIndex.d.ts

@@ -0,0 +1,8 @@
+import './style.css';
+export * as Webgl from './webgl/webglComponent';
+export * as Ultra from './ultra/ultraComponent';
+export * as ErrorStyle from './errors/errorStyle';
+export * as Errors from './errors/errors';
+export * as Urls from './urls';
+export type { MessageBoxProps } from './panels/messageBox';
+export * from './container';

package/dist/types/react-viewer/settings/menuSettings.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @module viw-webgl-react
+ */
+import * as VIM from '../../webgl-viewer/index';
+import { SettingsState } from './settingsState';
+/**
+ * JSX Component to interact with settings.
+ * @param viewer current viewer
+ * @param settings setting state
+ * @param visible will return null if this is false.
+ * @returns
+ */
+export declare function MenuSettings(props: {
+    viewer: VIM.Viewer;
+    settings: SettingsState;
+    visible: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/react-viewer/settings/settings.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @module viw-webgl-react
+ */
+/**
+ * Makes all fields optional recursively
+ * https://stackoverflow.com/questions/41980195/recursive-partialt-in-typescript
+ */
+export type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object ? RecursivePartial<T[P]> : T[P];
+};
+/**
+ * true, false or restricted
+ * Restricted: is false and cannot be changed by the user.
+ */
+export type UserBoolean = boolean | 'AlwaysTrue' | 'AlwaysFalse';
+export declare function isTrue(value: UserBoolean | boolean): value is true | "AlwaysTrue";
+export declare function isFalse(value: UserBoolean | boolean): value is false | "AlwaysFalse";
+/**
+ * Vim component settings, can either be set at component intialization or by user using UI.
+ */
+export type ComponentSettings = {
+    peformance: {
+        useFastMaterial: boolean;
+    };
+    isolation: {
+        enable: boolean;
+        useIsolationMaterial: boolean;
+    };
+    capacity: {
+        canFollowUrl: boolean;
+        canGoFullScreen: boolean;
+        useOrthographicCamera: boolean;
+        canDownload: boolean;
+    };
+    ui: {
+        logo: UserBoolean;
+        bimTreePanel: UserBoolean;
+        bimInfoPanel: UserBoolean;
+        performance: UserBoolean;
+        axesPanel: UserBoolean;
+        orthographic: UserBoolean;
+        resetCamera: UserBoolean;
+        enableGhost: UserBoolean;
+        controlBar: UserBoolean;
+        orbit: UserBoolean;
+        lookAround: UserBoolean;
+        pan: UserBoolean;
+        zoom: UserBoolean;
+        zoomWindow: UserBoolean;
+        zoomToFit: UserBoolean;
+        sectioningMode: UserBoolean;
+        measuringMode: UserBoolean;
+        toggleIsolation: UserBoolean;
+        projectInspector: UserBoolean;
+        settings: UserBoolean;
+        help: UserBoolean;
+        maximise: UserBoolean;
+    };
+};
+export type PartialComponentSettings = RecursivePartial<ComponentSettings>;
+export declare function anyUiAxesButton(settings: ComponentSettings): UserBoolean;
+export declare function anyUiCursorButton(settings: ComponentSettings): boolean;
+export declare function anyUiToolButton(settings: ComponentSettings): boolean;
+export declare function anyUiSettingButton(settings: ComponentSettings): boolean;
+export declare const defaultSettings: ComponentSettings;

package/dist/types/react-viewer/settings/settingsState.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @module viw-webgl-react
+ */
+import * as VIM from '../../webgl-viewer/index';
+import { ComponentSettings, PartialComponentSettings } from './settings';
+export type SettingsState = {
+    value: ComponentSettings;
+    update: (updater: (s: ComponentSettings) => void) => void;
+    register: (action: (s: ComponentSettings) => void) => void;
+};
+/**
+ * Returns a new state closure for settings.
+ */
+export declare function useSettings(viewer: VIM.Viewer, value: PartialComponentSettings): SettingsState;
+/**
+ * Apply given vim component settings to the given viewer.
+ */
+export declare function applySettings(viewer: VIM.Viewer, settings: ComponentSettings): void;

package/dist/types/react-viewer/settings/settingsStorage.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @module viw-webgl-react
+ */
+import { ComponentSettings, PartialComponentSettings } from './settings';
+export declare function getLocalComponentSettings(settings?: PartialComponentSettings): {};
+export declare function saveSettingsToLocal(value: ComponentSettings): void;

package/dist/types/react-viewer/sidePanel/sidePanel.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @module viw-webgl-react
+ */
+import React from 'react';
+import * as VIM from '../../webgl-viewer/index';
+import { SideState } from './sideState';
+import { VimComponentContainer } from '../container';
+/**
+ * Memoized version of the SidePanel.
+ */
+export declare const SidePanelMemo: React.MemoExoticComponent<typeof SidePanel>;
+/**
+ * JSX Component for collapsible and resizable side panel.
+ */
+export declare function SidePanel(props: {
+    container: VimComponentContainer;
+    side: SideState;
+    viewer: VIM.Viewer;
+    content: () => JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/react-viewer/sidePanel/sideState.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @module viw-webgl-react
+ */
+export type SideContent = 'none' | 'bim' | 'settings' | 'logs';
+export type SideState = {
+    minWidth: number;
+    toggleContent: (content: SideContent) => void;
+    popContent: () => void;
+    getNav: () => 'back' | 'close';
+    getContent: () => SideContent;
+    setContent: (value: SideContent) => void;
+    setHasBim: (value: boolean) => void;
+    getWidth: () => number;
+    setWidth: (value: number) => void;
+};
+/**
+ * Returns state closure for side panel
+ * @param useInspector inspector will only be displayed if this is true.
+ * @param defaultWidth default width of the side panel in pixel.
+ * @returns
+ */
+export declare function useSideState(useInspector: boolean, defaultWidth: number): SideState;

package/dist/types/react-viewer/ultra/ultraComponent.d.ts

@@ -0,0 +1,30 @@
+import '../style.css';
+import * as Ultra from '../../ultra-viewer/ultraViewerIndex';
+import { VimComponentContainer } from '../container';
+import { ModalRef } from '../panels/modal';
+export type UltraComponentRef = {
+    viewer: Ultra.Viewer;
+    modal: ModalRef;
+    dispose: () => void;
+    load(url: string): Ultra.ILoadRequest;
+};
+/**
+ * Creates a UI container along with a VIM.Viewer and its associated React component.
+ * @param container An optional container object. If none is provided, a container will be created.
+ * @param componentSettings UI Component settings.
+*  @param viewerSettings Viewer settings.
+ * @returns An object containing the resulting container, reactRoot, and viewer.
+ */
+export declare function createUltraComponent(container?: VimComponentContainer | HTMLElement): Promise<UltraComponentRef>;
+/**
+ * Represents a React component providing UI for the Vim viewer.
+ * @param container The container object containing root, gfx, and UI elements for the Vim viewer.
+ * @param viewer The Vim viewer instance for which UI is provided.
+ * @param onMount A callback function triggered when the component is mounted. Receives a reference to the Vim component.
+ * @param settings Optional settings for configuring the Vim component's behavior.
+ */
+export declare function UltraComponent(props: {
+    container: VimComponentContainer;
+    viewer: Ultra.Viewer;
+    onMount: (component: UltraComponentRef) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/react-viewer/ultra/ultraErrors.d.ts

@@ -0,0 +1,3 @@
+import * as Ultra from '../../ultra-viewer/ultraViewerIndex';
+export declare function getErrorMessage(state: Ultra.ClientState): import("../reactViewerIndex").MessageBoxProps;
+export declare function getRequestErrorMessage(url: string, error: Ultra.VimRequestErrorType): import("../reactViewerIndex").MessageBoxProps;

package/dist/types/react-viewer/urls.d.ts

@@ -0,0 +1,2 @@
+export declare const support = "https://docs.vimaec.com";
+export declare const supportControls = "https://docs.vimaec.com/docs/vim-cloud/webgl-navigation-and-controls-guide";

package/dist/types/react-viewer/webgl/viewerState.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @module viw-webgl-react
+ */
+import * as VIM from '../../webgl-viewer/index';
+import { AugmentedElement } from '../helpers/element';
+export type ViewerState = {
+    vim: VIM.Vim;
+    selection: VIM.Object3D[];
+    elements: AugmentedElement[];
+};
+export declare function useViewerState(viewer: VIM.Viewer): ViewerState;