vim-web 0.3.44-dev.8 → 0.3.44-dev.80

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

@@ -1,7 +1,8 @@
 /**
  * @module viw-webgl-react
- * Contains settings and type definitions for the Vim web component
+ * Contains settings and type definitions for the Vim web viewer
  */
+import { UserBoolean } from "./userBoolean";
 /**
  * Makes all fields optional recursively
  * @template T - The type to make recursively partial
@@ -11,29 +12,11 @@ export type RecursivePartial<T> = {
     [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object ? RecursivePartial<T[P]> : T[P];
 };
 /**
- * Represents a boolean value that can also be locked to always true or false
- * @typedef {boolean | 'AlwaysTrue' | 'AlwaysFalse'} UserBoolean
+ * Complete settings configuration for the Vim viewer
+ * @interface Settings
  */
-export type UserBoolean = boolean | 'AlwaysTrue' | 'AlwaysFalse';
-/**
- * Checks if a UserBoolean value is effectively true
- * @param {UserBoolean | boolean} value - The value to check
- * @returns {boolean} True if the value is true or 'AlwaysTrue'
- */
-export declare function isTrue(value: UserBoolean | boolean): value is true | "AlwaysTrue";
-/**
- * Checks if a UserBoolean value is effectively false
- * @param {UserBoolean | boolean} value - The value to check
- * @returns {boolean} True if the value is false or 'AlwaysFalse'
- */
-export declare function isFalse(value: UserBoolean | boolean): value is false | "AlwaysFalse";
-/**
- * Complete settings configuration for the Vim component
- * @interface ComponentSettings
- */
-export type ComponentSettings = {
+export type Settings = {
     materials: {
-        useFastMaterial: boolean;
         useGhostMaterial: boolean;
         smallGhostThreshold: number;
     };
@@ -54,14 +37,15 @@ export type ComponentSettings = {
         axesPanel: UserBoolean;
         orthographic: UserBoolean;
         resetCamera: UserBoolean;
-        enableGhost: UserBoolean;
         controlBar: UserBoolean;
         orbit: UserBoolean;
         lookAround: UserBoolean;
         pan: UserBoolean;
         zoom: UserBoolean;
         zoomWindow: UserBoolean;
-        zoomToFit: UserBoolean;
+        autoCamera: UserBoolean;
+        frameSelection: UserBoolean;
+        frameScene: UserBoolean;
         sectioningMode: UserBoolean;
         measuringMode: UserBoolean;
         toggleIsolation: UserBoolean;
@@ -74,34 +58,11 @@ export type ComponentSettings = {
 /**
  * Partial version of ComponentSettings where all properties are optional
  */
-export type PartialComponentSettings = RecursivePartial<ComponentSettings>;
-/**
- * Checks if any axes-related UI buttons are enabled
- * @param {ComponentSettings} settings - The component settings to check
- * @returns {boolean} True if any axes buttons are enabled
- */
-export declare function anyUiAxesButton(settings: ComponentSettings): UserBoolean;
-/**
- * Checks if any cursor-related UI buttons are enabled
- * @param {ComponentSettings} settings - The component settings to check
- * @returns {boolean} True if any cursor buttons are enabled
- */
-export declare function anyUiCursorButton(settings: ComponentSettings): boolean;
-/**
- * Checks if any tool-related UI buttons are enabled
- * @param {ComponentSettings} settings - The component settings to check
- * @returns {boolean} True if any tool buttons are enabled
- */
-export declare function anyUiToolButton(settings: ComponentSettings): boolean;
-/**
- * Checks if any settings-related UI buttons are enabled
- * @param {ComponentSettings} settings - The component settings to check
- * @returns {boolean} True if any settings buttons are enabled
- */
-export declare function anyUiSettingButton(settings: ComponentSettings): boolean;
+export type PartialSettings = RecursivePartial<Settings>;
 /**
- * Default settings configuration for the Vim component
+ * Default settings configuration for the Vim Viewer
  * @constant
- * @type {ComponentSettings}
+ * @type {Settings}
  */
-export declare const defaultSettings: ComponentSettings;
+export declare function getDefaultSettings(): Settings;
+export declare function createSettings(settings: PartialSettings): Settings;

package/dist/types/react-viewers/settings/{menuSettings.d.ts → settingsPanel.d.ts}

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

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

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

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

@@ -1,15 +1,15 @@
 /**
  * @module viw-webgl-react
  */
-import { ComponentSettings, PartialComponentSettings } from './settings';
+import { Settings, PartialSettings } from './settings';
 /**
- * Retrieves component settings from localStorage and applies permissions
- * @param settings - Partial component settings to apply permissions from
+ * Retrieves viewer settings from localStorage and applies permissions
+ * @param settings - Partial viewer settings to apply permissions from
  * @returns The stored settings with applied permissions, or empty object if retrieval fails
  */
-export declare function getLocalSettings(settings?: PartialComponentSettings): {};
+export declare function getLocalSettings(settings?: PartialSettings): {};
 /**
- * Saves component settings to localStorage after removing permissions
+ * Saves viewer settings to localStorage after removing permissions
  * @param value - Component settings to save
  */
-export declare function saveSettingsToLocal(value: ComponentSettings): void;
+export declare function saveSettingsToLocal(value: Settings): void;

package/dist/types/react-viewers/settings/userBoolean.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Represents a boolean value that can also be locked to always true or false
+ * @typedef {boolean | 'AlwaysTrue' | 'AlwaysFalse'} UserBoolean
+ */
+export type UserBoolean = boolean | 'AlwaysTrue' | 'AlwaysFalse';
+/**
+ * Checks if a UserBoolean value is effectively true
+ * @param {UserBoolean | boolean} value - The value to check
+ * @returns {boolean} True if the value is true or 'AlwaysTrue'
+ */
+export declare function isTrue(value: UserBoolean | boolean): value is true | "AlwaysTrue";
+/**
+ * Checks if a UserBoolean value is effectively false
+ * @param {UserBoolean | boolean} value - The value to check
+ * @returns {boolean} True if the value is false or 'AlwaysFalse'
+ */
+export declare function isFalse(value: UserBoolean | boolean): value is false | "AlwaysFalse";

package/dist/types/react-viewers/state/cameraState.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @module viw-webgl-react
+ */
+import * as THREE from 'three';
+import { SectionBoxRef } from './sectionBoxState';
+import { ActionRef, AsyncFuncRef, StateRef } from '../helpers/reactUtils';
+import { ISignal } from 'ste-signals';
+export interface CameraRef {
+    autoCamera: StateRef<boolean>;
+    reset: ActionRef;
+    frameSelection: AsyncFuncRef<void>;
+    frameScene: AsyncFuncRef<void>;
+    getSelectionBox: AsyncFuncRef<THREE.Box3 | undefined>;
+    getSceneBox: AsyncFuncRef<THREE.Box3 | undefined>;
+}
+interface ICameraAdapter {
+    onSelectionChanged: ISignal;
+    frameCamera: (box: THREE.Box3, duration: number) => void;
+    resetCamera: (duration: number) => void;
+    getSelectionBox: () => Promise<THREE.Box3 | undefined>;
+    getSceneBox: () => Promise<THREE.Box3 | undefined>;
+}
+export declare function useCamera(adapter: ICameraAdapter, section: SectionBoxRef): CameraRef;
+export {};

package/dist/types/react-viewers/state/controlBarState.d.ts

@@ -1,39 +1,54 @@
-import * as VIM from '../../core-viewers/webgl/index';
-import { ComponentCamera } from '../helpers/camera';
+import * as Core from "../../core-viewers";
+import { CameraRef } from './cameraState';
 import { CursorManager } from '../helpers/cursor';
-import { Isolation } from '../helpers/isolation';
-import { ComponentSettings } from '../settings/settings';
-import { SideState } from '../sidePanel/sideState';
-import * as Icons from '../panels/icons';
+import { Settings } from '../settings';
+import { SideState } from './sideState';
+import * as Icons from '../icons';
 import { SectionBoxRef } from './sectionBoxState';
-import { ModalRef } from '../panels/modal';
-import * as ControlBar from '../controlbar/controlBar';
+import { getMeasureState } from './measureState';
+import { ModalHandle } from '../panels/modal';
+import { IsolationRef } from './sharedIsolation';
+import * as ControlBar from '../controlbar';
 /**
  * Returns a control bar section for the section box.
  */
 export declare function controlBarSectionBox(section: SectionBoxRef, hasSelection: boolean): ControlBar.IControlBarSection;
-/**
- * Combines all control bar sections into one control bar.
- */
-export declare function useControlBar(viewer: VIM.Viewer, camera: ComponentCamera, modal: ModalRef, side: SideState, isolation: Isolation, cursor: CursorManager, settings: ComponentSettings, section: SectionBoxRef, customization: ControlBar.ControlBarCustomization | undefined): (ControlBar.IControlBarSection | {
+export declare function controlBarMeasure(settings: Settings, measure: ReturnType<typeof getMeasureState>): {
     id: string;
     enable: () => boolean;
     style: string;
-    buttons: ({
+    buttons: {
         id: string;
         enabled: () => boolean;
+        isOn: () => boolean;
         tip: string;
         action: () => void;
-        icon: typeof Icons.frameSelection;
-        isOn: () => boolean;
-        style: typeof ControlBar.buttonDefaultStyle;
-    } | {
+        icon: typeof Icons.measure;
+        style: typeof ControlBar.Style.buttonDefaultStyle;
+    }[];
+};
+export declare function controlBarCamera(camera: CameraRef): ControlBar.IControlBarSection;
+export declare function controlBarSelection(isolation: IsolationRef): ControlBar.IControlBarSection;
+/**
+ * Combines all control bar sections into one control bar.
+ */
+export declare function useControlBar(viewer: Core.Webgl.Viewer, camera: CameraRef, modal: ModalHandle, side: SideState, cursor: CursorManager, settings: Settings, section: SectionBoxRef, isolationRef: IsolationRef, customization: ControlBar.ControlBarCustomization | undefined): (ControlBar.IControlBarSection | {
+    id: string;
+    enable: () => boolean;
+    style: string;
+    buttons: {
         id: string;
         enabled: () => boolean;
+        isOn: () => boolean;
         tip: string;
         action: () => void;
-        icon: typeof Icons.toggleIsolation;
-        style: typeof ControlBar.buttonDefaultStyle;
-        isOn?: undefined;
-    })[];
+        icon: typeof Icons.measure;
+        style: typeof ControlBar.Style.buttonDefaultStyle;
+    }[];
 })[];
+/**
+ * Checks if any settings-related UI buttons are enabled
+ * @param {Settings} settings - The viewer settings to check
+ * @returns {boolean} True if any settings buttons are enabled
+ */
+export declare function anyUiSettingButton(settings: Settings): boolean;

package/dist/types/react-viewers/state/index.d.ts

@@ -0,0 +1,9 @@
+export * from './cameraState';
+export * from './controlBarState';
+export * from './fullScreenState';
+export * from './measureState';
+export * from './pointerState';
+export * from './sectionBoxState';
+export * from './sharedIsolation';
+export * from './sideState';
+export * from './viewerInputs';

package/dist/types/react-viewers/state/measureState.d.ts

@@ -1,6 +1,6 @@
-import { WebglViewer } from '../../index';
+import * as Core from '../../core-viewers';
 import { CursorManager } from '../helpers/cursor';
-export declare function getMeasureState(viewer: WebglViewer.Viewer, cursor: CursorManager): {
+export declare function getMeasureState(viewer: Core.Webgl.Viewer, cursor: CursorManager): {
     active: boolean;
     toggle: () => void;
     clear: () => void;

package/dist/types/react-viewers/state/pointerState.d.ts

@@ -1,6 +1,6 @@
-import * as VIM from '../../core-viewers/webgl/index';
-export declare function getPointerState(viewer: VIM.Viewer): {
-    mode: VIM.PointerMode;
-    setMode: import("react").Dispatch<import("react").SetStateAction<VIM.PointerMode>>;
-    onButton: (target: VIM.PointerMode) => void;
+import * as Core from '../../core-viewers';
+export declare function getPointerState(viewer: Core.Webgl.Viewer): {
+    mode: Core.PointerMode;
+    setMode: import("react").Dispatch<import("react").SetStateAction<Core.PointerMode>>;
+    onButton: (target: Core.PointerMode) => void;
 };

package/dist/types/react-viewers/state/sectionBoxState.d.ts

@@ -1,5 +1,6 @@
 import * as THREE from 'three';
 import { ISignal } from 'ste-signals';
+import { ArgActionRef, AsyncFuncRef, StateRef } from '../helpers/reactUtils';
 export type Offsets = {
     topOffset: string;
     sideOffset: string;
@@ -7,28 +8,27 @@ export type Offsets = {
 };
 export type OffsetField = keyof Offsets;
 export interface SectionBoxRef {
-    getEnable: () => boolean;
-    setEnable: (enable: boolean) => void;
-    getVisible: () => boolean;
-    setVisible: React.Dispatch<React.SetStateAction<boolean>>;
-    getAuto: () => boolean;
-    setAuto: (auto: boolean) => void;
-    sectionSelection: () => void;
-    sectionReset: () => void;
-    section: (box: THREE.Box3) => void;
-    getShowOffsetPanel: () => boolean;
-    setShowOffsetPanel: React.Dispatch<React.SetStateAction<boolean>>;
-    getOffsetText: (field: OffsetField) => string;
-    setOffsetText: (field: OffsetField, value: string) => void;
-    validate: (field: OffsetField) => void;
+    enable: StateRef<boolean>;
+    visible: StateRef<boolean>;
+    auto: StateRef<boolean>;
+    sectionSelection: AsyncFuncRef<void>;
+    sectionScene: AsyncFuncRef<void>;
+    sectionBox: ArgActionRef<THREE.Box3>;
+    getBox: () => THREE.Box3;
+    showOffsetPanel: StateRef<boolean>;
+    topOffset: StateRef<number>;
+    sideOffset: StateRef<number>;
+    bottomOffset: StateRef<number>;
+    getSelectionBox: AsyncFuncRef<THREE.Box3 | undefined>;
+    getSceneBox: AsyncFuncRef<THREE.Box3>;
 }
 export interface SectionBoxAdapter {
+    setClip: (b: boolean) => void;
     setVisible: (visible: boolean) => void;
     getBox: () => THREE.Box3;
-    fitBox: (box: THREE.Box3) => void;
-    getSelectionBox: () => Promise<THREE.Box3 | undefined>;
-    getRendererBox: () => Promise<THREE.Box3>;
+    setBox: (box: THREE.Box3) => void;
     onSelectionChanged: ISignal;
-    onSceneChanged: ISignal;
+    getSelectionBox: () => Promise<THREE.Box3 | undefined>;
+    getSceneBox: () => Promise<THREE.Box3>;
 }
 export declare function useSectionBox(adapter: SectionBoxAdapter): SectionBoxRef;

package/dist/types/react-viewers/state/sharedIsolation.d.ts

@@ -0,0 +1,38 @@
+import { RefObject } from "react";
+import { FuncRef, StateRef } from "../helpers/reactUtils";
+import { ISignal } from "ste-signals";
+export type VisibilityStatus = 'all' | 'allButSelection' | 'onlySelection' | 'some' | 'none';
+export interface IsolationRef {
+    adapter: RefObject<IsolationAdapter>;
+    visibility: StateRef<VisibilityStatus>;
+    autoIsolate: StateRef<boolean>;
+    showPanel: StateRef<boolean>;
+    showGhost: StateRef<boolean>;
+    ghostOpacity: StateRef<number>;
+    showRooms: StateRef<boolean>;
+    onAutoIsolate: FuncRef<void>;
+    onVisibilityChange: FuncRef<void>;
+}
+export interface IsolationAdapter {
+    onSelectionChanged: ISignal;
+    onVisibilityChange: ISignal;
+    computeVisibility: () => VisibilityStatus;
+    hasSelection(): boolean;
+    hasVisibleSelection: () => boolean;
+    hasHiddenSelection: () => boolean;
+    clearSelection(): void;
+    isolateSelection(): void;
+    hideSelection(): void;
+    showSelection(): void;
+    isolate(instances: number[]): void;
+    show(instances: number[]): void;
+    hide(instances: number[]): void;
+    hideAll(): void;
+    showAll(): void;
+    showGhost(show: boolean): void;
+    getGhostOpacity(): number;
+    setGhostOpacity(opacity: number): void;
+    getShowRooms(): boolean;
+    setShowRooms(show: boolean): void;
+}
+export declare function useSharedIsolation(adapter: IsolationAdapter): IsolationRef;

package/dist/types/react-viewers/state/viewerInputs.d.ts

@@ -0,0 +1,3 @@
+import { InputHandler } from "../../core-viewers/shared";
+import { CameraRef } from "./cameraState";
+export declare function useViewerInput(handler: InputHandler, camera: CameraRef): void;

package/dist/types/react-viewers/ultra/camera.d.ts

@@ -0,0 +1,3 @@
+import * as Core from "../../core-viewers/ultra";
+import { SectionBoxRef } from "../state/sectionBoxState";
+export declare function useUltraCamera(viewer: Core.Viewer, section: SectionBoxRef): import("../state/cameraState").CameraRef;

package/dist/types/react-viewers/ultra/controlBar.d.ts

@@ -0,0 +1,6 @@
+import * as Core from '../../core-viewers/ultra';
+import { ControlBarCustomization } from '../controlbar/controlBar';
+import { CameraRef } from '../state/cameraState';
+import { SectionBoxRef } from '../state/sectionBoxState';
+import { IsolationRef } from '../state/sharedIsolation';
+export declare function useUltraControlBar(viewer: Core.Viewer, section: SectionBoxRef, isolation: IsolationRef, camera: CameraRef, customization: ControlBarCustomization | undefined): import("../controlbar").IControlBarSection[];

package/dist/types/react-viewers/ultra/errors/ultraErrors.d.ts

@@ -1,3 +1,3 @@
-import * as Ultra from '../../../core-viewers/ultra';
-export declare function getErrorMessage(state: Ultra.ClientState): import("../..").MessageBoxProps;
-export declare function getRequestErrorMessage(source: Ultra.VimSource, error: Ultra.VimRequestErrorType): import("../..").MessageBoxProps;
+import * as Core from '../../../core-viewers';
+export declare function getErrorMessage(state: Core.Ultra.ClientState): import("../..").MessageBoxProps;
+export declare function getRequestErrorMessage(serverUrl: string, source: Core.Ultra.VimSource, error: Core.Ultra.VimRequestErrorType): import("../..").MessageBoxProps;

package/dist/types/react-viewers/ultra/index.d.ts

@@ -1 +1,2 @@
-export * from './ultraComponent';
+export * from './viewer';
+export * from './viewerRef';

package/dist/types/react-viewers/ultra/isolation.d.ts

@@ -0,0 +1,3 @@
+import * as Core from "../../core-viewers";
+import Viewer = Core.Ultra.Viewer;
+export declare function useUltraIsolation(viewer: Viewer): import("../state/sharedIsolation").IsolationRef;

package/dist/types/react-viewers/ultra/modal.d.ts

@@ -0,0 +1,5 @@
+import { ModalHandle } from "../panels/modal";
+import * as Core from '../../core-viewers';
+import { RefObject } from "react";
+export declare function updateModal(modal: RefObject<ModalHandle>, state: Core.Ultra.ClientState): void;
+export declare function updateProgress(request: Core.Ultra.ILoadRequest, modal: ModalHandle): Promise<void>;

package/dist/types/react-viewers/ultra/sectionBox.d.ts

@@ -0,0 +1,3 @@
+import * as Core from '../../core-viewers';
+import { SectionBoxRef } from '../state/sectionBoxState';
+export declare function useUltraSectionBox(viewer: Core.Ultra.Viewer): SectionBoxRef;

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

@@ -0,0 +1,21 @@
+import * as Core from '../../core-viewers';
+import { Container } from '../container';
+import { ViewerRef } from './viewerRef';
+/**
+ * Creates a UI container along with a VIM.Viewer and its associated React viewer.
+ * @param container An optional container object. If none is provided, a container will be created.
+ * @returns An object containing the resulting container, reactRoot, and viewer.
+ */
+export declare function createViewer(container?: Container | HTMLElement): Promise<ViewerRef>;
+/**
+ * Represents a React viewer 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 viewer is mounted. Receives a reference to the Vim viewer.
+ * @param settings Optional settings for configuring the Vim viewer's behavior.
+ */
+export declare function Viewer(props: {
+    container: Container;
+    core: Core.Ultra.Viewer;
+    onMount: (viewer: ViewerRef) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/react-viewers/ultra/viewerRef.d.ts

@@ -0,0 +1,47 @@
+import * as Core from '../../core-viewers/ultra';
+import { ModalHandle } from '../panels/modal';
+import { CameraRef } from '../state/cameraState';
+import { SectionBoxRef } from '../state/sectionBoxState';
+import { IsolationRef } from '../state/sharedIsolation';
+import { ControlBarRef } from '../controlbar';
+import { GenericPanelHandle } from '../generic/';
+export type ViewerRef = {
+    /**
+     * The Vim viewer instance associated with the viewer.
+     */
+    core: Core.Viewer;
+    /**
+     * API to manage the modal dialog.
+     */
+    modal: ModalHandle;
+    /**
+     * API to manage the section box.
+     */
+    sectionBox: SectionBoxRef;
+    /**
+     * API to customize the control.
+     */
+    controlBar: ControlBarRef;
+    /**
+     * Camera API to interact with the viewer camera at a higher level.
+     */
+    camera: CameraRef;
+    isolation: IsolationRef;
+    /**
+     * API to interact with the isolation panel.
+     */
+    isolationPanel: GenericPanelHandle;
+    /**
+     * API to interact with the isolation panel.
+     */
+    sectionBoxPanel: GenericPanelHandle;
+    /**
+     * Disposes of the viewer and its resources.
+     */
+    dispose: () => void;
+    /**
+     * Loads a file into the viewer.
+     * @param url The URL of the file to load.
+     */
+    load(url: Core.VimSource): Core.ILoadRequest;
+};

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

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

package/dist/types/react-viewers/webgl/camera.d.ts

@@ -0,0 +1,3 @@
+import * as Core from "../../core-viewers";
+import { SectionBoxRef } from "../state/sectionBoxState";
+export declare function useWebglCamera(viewer: Core.Webgl.Viewer, section: SectionBoxRef): import("../state/cameraState").CameraRef;

package/dist/types/react-viewers/webgl/index.d.ts

@@ -1,8 +1,3 @@
-export * from './webglComponent';
-export * as ContextMenu from '../panels/contextMenu';
-export * as BimInfo from '../bim/bimInfoData';
-export * as ControlBar from '../controlbar/controlBar';
-export { LoadRequest } from '../helpers/loadRequest';
-export * as Refs from './webglComponentRef';
-export { getLocalSettings as getLocalSettings } from '../settings/settingsStorage';
-export { type ComponentSettings as Settings, type PartialComponentSettings as PartialSettings, defaultSettings } from '../settings/settings';
+export * from './viewer';
+export * from './viewerRef';
+export type * from './loading';

package/dist/types/react-viewers/webgl/inputsBindings.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module viw-webgl-react
+ */
+import * as Core from '../../core-viewers';
+import { SideState } from '../state/sideState';
+import { CameraRef } from '../state/cameraState';
+import { IsolationRef } from '../state/sharedIsolation';
+export declare function applyWebglBindings(viewer: Core.Webgl.Viewer, camera: CameraRef, isolation: IsolationRef, sideState: SideState): void;

package/dist/types/react-viewers/webgl/isolation.d.ts

@@ -0,0 +1,2 @@
+import * as Core from "../../core-viewers";
+export declare function useWebglIsolation(viewer: Core.Webgl.Viewer): import("../state/sharedIsolation").IsolationRef;

package/dist/types/react-viewers/webgl/{webglLoading.d.ts → loading.d.ts}

@@ -1,9 +1,9 @@
 /**
  * @module viw-webgl-react
  */
-import * as VIM from '../../core-viewers/webgl/index';
+import * as Core from '../../core-viewers';
 import { LoadRequest } from '../helpers/loadRequest';
-import { ModalRef } from '../panels/modal';
+import { ModalHandle } from '../panels/modal';
 type AddSettings = {
     /**
      * Controls whether to frame the camera on a vim everytime it is updated.
@@ -16,7 +16,7 @@ type AddSettings = {
      */
     loadEmpty?: boolean;
 };
-export type OpenSettings = VIM.VimPartialSettings & AddSettings;
+export type OpenSettings = Core.Webgl.VimPartialSettings & AddSettings;
 export type LoadingError = {
     url: string;
     error: string;
@@ -28,11 +28,11 @@ export type LoadingError = {
 export declare class ComponentLoader {
     private _viewer;
     private _modal;
-    constructor(viewer: VIM.Viewer, modal: ModalRef);
+    constructor(viewer: Core.Webgl.Viewer, modal: React.RefObject<ModalHandle>);
     /**
      * Event emitter for progress updates.
      */
-    onProgress(p: VIM.IProgressLogs): void;
+    onProgress(p: Core.Webgl.IProgressLogs): void;
     /**
        * Event emitter for completion notifications.
      */
@@ -48,20 +48,20 @@ export declare class ComponentLoader {
      * @param onProgress Optional callback function to track progress during opening.
      * Receives progress logs as input.
      */
-    open(source: VIM.RequestSource, settings: OpenSettings, onProgress?: (p: VIM.IProgressLogs) => void): Promise<VIM.Vim>;
+    open(source: Core.Webgl.RequestSource, settings: OpenSettings, onProgress?: (p: Core.Webgl.IProgressLogs) => void): Promise<Core.Webgl.Vim>;
     /**
      * Creates a new load request for the provided source and settings.
      * @param source The url to the vim file or a buffer of the file.
      * @param settings Settings to apply to vim file.
      * @returns A new load request instance to track progress and get result.
      */
-    request(source: VIM.RequestSource, settings?: VIM.VimPartialSettings): LoadRequest;
-    add(vim: VIM.Vim, settings?: AddSettings): void;
+    request(source: Core.Webgl.RequestSource, settings?: Core.Webgl.VimPartialSettings): LoadRequest;
+    add(vim: Core.Webgl.Vim, settings?: AddSettings): void;
     /**
      * Removes the vim from the viewer and disposes it.
      * @param vim Vim to remove from the viewer.
      */
-    remove(vim: VIM.Vim): void;
+    remove(vim: Core.Webgl.Vim): void;
     private initVim;
 }
 export {};

package/dist/types/react-viewers/webgl/sectionBox.d.ts

@@ -0,0 +1,3 @@
+import * as Core from '../../core-viewers';
+import { SectionBoxRef } from '../state/sectionBoxState';
+export declare function useWebglSectionBox(viewer: Core.Webgl.Viewer): SectionBoxRef;