vim-web 0.3.44-dev.7 → 0.3.44-dev.70

package/dist/types/react-viewers/helpers/reactUtils.d.ts

@@ -0,0 +1,273 @@
+/**
+ * @module state-action-refs
+ *
+ * This module exports various React hooks and TypeScript interfaces to create references for state,
+ * actions, and functions. These references allow you to store and manipulate values and functions,
+ * as well as dynamically inject additional behavior (using prepend and append methods) into their call chains.
+ *
+ * The provided hooks include:
+ * - useStateRef: A state reference with event dispatching and validation.
+ * - useActionRef: A reference for an action (a function with no arguments).
+ * - useArgActionRef: A reference for an action that accepts an argument.
+ * - useFuncRef: A reference for a function returning a value.
+ * - useAsyncFuncRef: A reference for an asynchronous function.
+ * - useArgFuncRef: A reference for a function that accepts an argument and returns a value.
+ */
+import { ISimpleEvent } from "ste-simple-events";
+/**
+ * Interface for a state reference.
+ * Provides methods to get, set, and confirm the current state.
+ */
+export interface StateRef<T> {
+    /**
+     * Returns the current state value.
+     */
+    get(): T;
+    /**
+     * Updates the state to the provided value.
+     * @param value - The new state value.
+     */
+    set(value: T): void;
+    /**
+     * Confirms the current state (potentially applying a confirmation transformation).
+     */
+    confirm(): void;
+    onChange: ISimpleEvent<T>;
+}
+export interface StateRefresher {
+    refresh: () => void;
+}
+export declare function useRefresher(): StateRefresher;
+/**
+ * A custom hook that creates a state reference.
+ * The reference provides access to the state, along with event dispatching, validation, and confirmation logic.
+ *
+ * @param initialValue - The initial state value.
+ * @returns An object implementing StateRef along with additional helper hooks.
+ */
+export declare function useStateRef<T>(initialValue: T | (() => T)): {
+    /**
+     * Returns the current state value.
+     */
+    get(): T;
+    set: (value: T) => void;
+    onChange: ISimpleEvent<T>;
+    /**
+     * Confirms the current state by applying the confirm function and updating the state.
+     */
+    confirm(): void;
+    /**
+     * Registers a callback to be invoked when the state changes.
+     * Accepts a sync function, a cleanup function, or a function returning a Promise<void> (which will be ignored).
+     *
+     * @param on - The callback function that receives the new state value.
+     */
+    useOnChange(on: (value: T) => void | (() => void) | Promise<void>): void;
+    /**
+     * Memoizes a value based on the current state and additional dependencies.
+     * @param on - A function that computes a value based on the current state.
+     * @param deps - Optional additional dependencies.
+     * @returns The memoized value.
+     */
+    useMemo<TOut>(on: (value: T) => TOut, deps?: any[]): TOut;
+    /**
+     * Sets a validation function to process any new state value before updating.
+     * @param on - A function that validates (and optionally transforms) the new state value.
+     */
+    useValidate(on: (next: T, current: T) => T): void;
+    /**
+     * Sets a confirmation function to process the state value during confirmation.
+     * @param on - A function that confirms (and optionally transforms) the current state value.
+     */
+    useConfirm(on: (value: T) => T): void;
+};
+/**
+ * Interface for an action reference (a function with no arguments).
+ * Provides methods to call, get, set, and inject code before or after the stored function.
+ */
+export interface ActionRef {
+    /**
+     * Invokes the stored action.
+     */
+    call(): void;
+    /**
+     * Retrieves the current action function.
+     * @returns The stored action function.
+     */
+    get(): () => void;
+    /**
+     * Sets the stored action function.
+     * @param fn - The new action function.
+     */
+    set(fn: () => void): void;
+    /**
+     * Prepends a function to be executed before the stored action.
+     * @param fn - The function to run before the original action.
+     */
+    prepend(fn: () => void): void;
+    /**
+     * Appends a function to be executed after the stored action.
+     * @param fn - The function to run after the original action.
+     */
+    append(fn: () => void): void;
+}
+/**
+ * Custom hook to create an action reference.
+ *
+ * @param action - The initial action function.
+ * @returns An object implementing ActionRef.
+ */
+export declare function useActionRef(action: () => void): ActionRef;
+/**
+ * Interface for an action reference that accepts an argument.
+ * Provides methods to call with an argument, get, set, and inject code before or after the stored function.
+ */
+export interface ArgActionRef<T> {
+    /**
+     * Invokes the stored action with the provided argument.
+     * @param arg - The argument to pass to the action.
+     */
+    call(arg: T): void;
+    /**
+     * Retrieves the current action function.
+     * @returns The stored action function.
+     */
+    get(): (arg: T) => void;
+    /**
+     * Sets the stored action function.
+     * @param fn - The new action function.
+     */
+    set(fn: (arg: T) => void): void;
+    /**
+     * Prepends a function to be executed before the stored action.
+     * @param fn - The function to run before the original action.
+     */
+    prepend(fn: (arg: T) => void): void;
+    /**
+     * Appends a function to be executed after the stored action.
+     * @param fn - The function to run after the original action.
+     */
+    append(fn: (arg: T) => void): void;
+}
+/**
+ * Custom hook to create an argument-based action reference.
+ *
+ * @param action - The initial action function that accepts an argument.
+ * @returns An object implementing ArgActionRef.
+ */
+export declare function useArgActionRef<T>(action: (arg: T) => void): ArgActionRef<T>;
+/**
+ * Interface for a function reference that returns a value.
+ * Provides methods to call, get, set, and inject code before or after the stored function.
+ */
+export interface FuncRef<T> {
+    /**
+     * Invokes the stored function and returns its value.
+     * @returns The result of the function call.
+     */
+    call(): T;
+    /**
+     * Retrieves the current function.
+     * @returns The stored function.
+     */
+    get(): () => T;
+    /**
+     * Sets the stored function.
+     * @param fn - The new function.
+     */
+    set(fn: () => T): void;
+    /**
+     * Prepends a function to be executed before the stored function.
+     * @param fn - The function to run before the original function.
+     */
+    prepend(fn: () => void): void;
+    /**
+     * Appends a function to be executed after the stored function.
+     * @param fn - The function to run after the original function.
+     */
+    append(fn: () => void): void;
+}
+/**
+ * Custom hook to create a function reference.
+ *
+ * @param fn - The initial function.
+ * @returns An object implementing FuncRef.
+ */
+export declare function useFuncRef<T>(fn: () => T): FuncRef<T>;
+/**
+ * Interface for an asynchronous function reference.
+ * Provides methods to call, get, set, and inject code before or after the stored async function.
+ */
+export interface AsyncFuncRef<T> {
+    /**
+     * Invokes the stored asynchronous function and returns a promise of its result.
+     * @returns A promise resolving to the result of the async function.
+     */
+    call(): Promise<T>;
+    /**
+     * Retrieves the current asynchronous function.
+     * @returns The stored async function.
+     */
+    get(): () => Promise<T>;
+    /**
+     * Sets the stored asynchronous function.
+     * @param fn - The new async function.
+     */
+    set(fn: () => Promise<T>): void;
+    /**
+     * Prepends a function to be executed before the stored async function.
+     * @param fn - The function to run before the original async function.
+     */
+    prepend(fn: () => Promise<void> | void): void;
+    /**
+     * Appends a function to be executed after the stored async function.
+     * @param fn - The function to run after the original async function.
+     */
+    append(fn: () => Promise<void> | void): void;
+}
+/**
+ * Custom hook to create an asynchronous function reference.
+ *
+ * @param fn - The initial asynchronous function.
+ * @returns An object implementing AsyncFuncRef.
+ */
+export declare function useAsyncFuncRef<T>(fn: () => Promise<T>): AsyncFuncRef<T>;
+/**
+ * Interface for a function reference that accepts an argument and returns a result.
+ * Provides methods to call, get, set, and inject code before or after the stored function.
+ */
+export interface ArgFuncRef<TArg, TResult> {
+    /**
+     * Invokes the stored function with the provided argument.
+     * @param arg - The argument to pass to the function.
+     * @returns The result of the function call.
+     */
+    call(arg: TArg): TResult;
+    /**
+     * Retrieves the current function.
+     * @returns The stored function.
+     */
+    get(): (arg: TArg) => TResult;
+    /**
+     * Sets the stored function.
+     * @param fn - The new function.
+     */
+    set(fn: (arg: TArg) => TResult): void;
+    /**
+     * Prepends a function to be executed before the stored function.
+     * @param fn - The function to run before the original function.
+     */
+    prepend(fn: (arg: TArg) => void): void;
+    /**
+     * Appends a function to be executed after the stored function.
+     * @param fn - The function to run after the original function.
+     */
+    append(fn: (arg: TArg) => void): void;
+}
+/**
+ * Custom hook to create an argument-based function reference.
+ *
+ * @param fn - The initial function that accepts an argument and returns a result.
+ * @returns An object implementing ArgFuncRef.
+ */
+export declare function useArgFuncRef<TArg, TResult>(fn: (arg: TArg) => TResult): ArgFuncRef<TArg, TResult>;

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

@@ -1,4 +1,4 @@
-import { UserBoolean } from '../settings/settings';
+import { UserBoolean } from '../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;

package/dist/types/react-viewers/{panels/icons.d.ts → icons.d.ts}

@@ -10,6 +10,8 @@ export type IconOptions = {
     fill: string;
     className?: string;
 };
+export declare function pointer({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function filter({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
 export declare function slidersHoriz({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
 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;
@@ -27,6 +29,8 @@ export declare function arrowLeft({ height, width, fill, className }: IconOption
 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 frameScene({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function autoCamera({ 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;
@@ -36,6 +40,11 @@ export declare function pan({ height, width, fill, className }: IconOptions): im
 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 showAll({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function showSelection({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function hideSelection({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function isolateSelection({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;
+export declare function autoIsolate({ 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 sectionBoxSettings({ height, width, fill, className }: IconOptions): import("react/jsx-runtime").JSX.Element;

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

@@ -1,9 +1,13 @@
 import './style.css';
-export * as WebglReact from './webgl/index';
-export * as UltraReact from './ultra/index';
-export * as ErrorStyle from './errors/errorStyle';
-export * as Errors from './errors/errors';
+export * from './bim';
+export * as ControlBar from './controlbar';
+export * as Icons from './icons';
+export * as Settings from './settings';
+export * as Webgl from './webgl';
+export * as Ultra from './ultra';
+export * as Errors from './errors';
 export * as Urls from './urls';
-export * as Icons from './panels/icons';
-export type { MessageBoxProps } from './panels/messageBox';
 export * from './container';
+export * from './panels';
+export type * from './helpers';
+export type * from './state';

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

@@ -2,8 +2,8 @@
  * @module viw-webgl-react
  */
 import React from 'react';
-import * as VIM from '../../core-viewers/webgl/index';
-import { ComponentCamera } from '../helpers/camera';
+import * as Core from '../../core-viewers';
+import { CameraRef } from '../state/cameraState';
 import { SettingsState } from '../settings/settingsState';
 /**
  * Memoized version of the AxesPanelMemo.
@@ -13,8 +13,8 @@ export declare const AxesPanelMemo: React.MemoExoticComponent<typeof AxesPanel>;
  * JSX Component for axes gizmo.
  */
 declare function AxesPanel(props: {
-    viewer: VIM.Viewer;
-    camera: ComponentCamera;
+    viewer: Core.Webgl.Viewer;
+    camera: CameraRef;
     settings: SettingsState;
 }): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -2,12 +2,22 @@
  * @module viw-webgl-react
  */
 import React from 'react';
-import { WebglViewer } from '../..';
-import { Isolation } from '../helpers/isolation';
-import { ComponentCamera } from '../helpers/camera';
+import { CameraRef } from '../state/cameraState';
 import { TreeActionRef } from '../bim/bimTree';
 import { ModalRef } from './modal';
+import { IsolationRef } from '../state/sharedIsolation';
+import * as Core from '../../core-viewers';
 type ClickCallback = React.MouseEvent<HTMLDivElement, MouseEvent>;
+/**
+ * Reference to manage context menu functionality in the viewer.
+ */
+export type ContextMenuRef = {
+    /**
+     * Defines a callback function to dynamically customize the context menu.
+     * @param customization The configuration object specifying the customization options for the context menu.
+     */
+    customize: (customization: ContextMenuCustomization) => void;
+};
 export declare function showContextMenu(position: {
     x: number;
     y: number;
@@ -59,16 +69,16 @@ export type ContextMenuCustomization = (e: ContextMenuElement[]) => ContextMenuE
 /**
  * Memoized version of VimContextMenu.
  */
-export declare const VimContextMenuMemo: React.MemoExoticComponent<typeof VimContextMenu>;
+export declare const VimContextMenuMemo: React.MemoExoticComponent<typeof ContextMenu>;
 /**
- * Context menu component definition according to current state.
+ * Context menu viewer definition according to current state.
  */
-export declare function VimContextMenu(props: {
-    viewer: WebglViewer.Viewer;
-    camera: ComponentCamera;
+export declare function ContextMenu(props: {
+    viewer: Core.Webgl.Viewer;
+    camera: CameraRef;
     modal: ModalRef;
-    isolation: Isolation;
-    selection: WebglViewer.Object3D[];
+    isolation: IsolationRef;
+    selection: Core.Webgl.Element3D[];
     customization?: (e: ContextMenuElement[]) => ContextMenuElement[];
     treeRef: React.MutableRefObject<TreeActionRef | undefined>;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/types/react-viewers/panels/genericPanel.d.ts

@@ -0,0 +1,26 @@
+import { StateRef } from "../helpers/reactUtils";
+interface BasePanelField {
+    id: string;
+    label: string;
+}
+export interface PanelFieldText extends BasePanelField {
+    type: "text";
+    state: StateRef<string>;
+}
+export interface PanelFieldNumber extends BasePanelField {
+    type: "number";
+    state: StateRef<number>;
+}
+export interface PanelFieldBool extends BasePanelField {
+    type: "bool";
+    state: StateRef<boolean>;
+}
+export type PanelField = PanelFieldText | PanelFieldBool | PanelFieldNumber;
+export interface GenericPanelProps {
+    showPanel: StateRef<boolean>;
+    header?: React.ReactNode;
+    fields: PanelField[];
+    onClose?: () => void;
+}
+export declare function GenericPanel(props: GenericPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,14 @@
+export * as ContextMenu from './contextMenu';
+export type * from './axesPanel';
+export type * from './genericPanel';
+export type * from './help';
+export type * from './loadingBox';
+export type * from './logo';
+export type * from './messageBox';
+export type * from './modal';
+export type * from './overlay';
+export type * from './performance';
+export type * from './renderSettingsPanel';
+export type * from './restOfScreen';
+export type * from './sectionBoxPanel';
+export type * from './toast';

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

@@ -17,9 +17,9 @@ export type LoadingBoxPropsTyped = LoadingBoxProps & {
     type: 'loading';
 };
 /**
- * LoadingBox component that displays a loading message or other messages.
+ * LoadingBox viewer 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.
+ * @returns The LoadingBox viewer or null if no content is provided.
  */
 export declare function LoadingBox(props: {
     content: LoadingBoxProps;

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

@@ -2,7 +2,7 @@ export type MessageBoxProps = {
     title: string;
     body: string | JSX.Element;
     footer?: string | JSX.Element;
-    canClose: boolean;
+    canClose?: boolean;
     onClose?: () => void;
 };
 export type MessageBoxPropsTyped = MessageBoxProps & {

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

@@ -1,18 +1,18 @@
+import React from 'react';
 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;
+    canClose?: boolean;
     onClose?: () => void;
 };
 export type ModalRef = {
-    current: ModalPropsTyped | undefined;
+    getActiveState(): 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;
+export declare const Modal: React.ForwardRefExoticComponent<{
+    canFollowLinks: boolean;
+} & React.RefAttributes<ModalRef>>;

package/dist/types/react-viewers/panels/renderSettingsPanel.d.ts

@@ -0,0 +1,4 @@
+import { IsolationRef } from "../state/sharedIsolation";
+export declare function IsolationSettingsPanel(props: {
+    state: IsolationRef;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/react-viewers/panels/restOfScreen.d.ts

@@ -1,4 +1,4 @@
-import { SideState } from '../sidePanel/sideState';
+import { SideState } from '../state/sideState';
 export declare function RestOfScreen(props: {
     side: SideState;
     content: () => JSX.Element;

package/dist/types/react-viewers/{sidePanel → panels}/sidePanel.d.ts

@@ -2,8 +2,8 @@
  * @module viw-webgl-react
  */
 import React from 'react';
-import * as VIM from '../../core-viewers/webgl/index';
-import { SideState } from './sideState';
+import * as Core from '../../core-viewers';
+import { SideState } from '../state/sideState';
 import { Container } from '../container';
 /**
  * Memoized version of the SidePanel.
@@ -15,6 +15,6 @@ export declare const SidePanelMemo: React.MemoExoticComponent<typeof SidePanel>;
 export declare function SidePanel(props: {
     container: Container;
     side: SideState;
-    viewer: VIM.Viewer;
+    viewer: Core.Webgl.Viewer;
     content: () => JSX.Element;
 }): import("react/jsx-runtime").JSX.Element;

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

@@ -2,8 +2,8 @@
  * @module viw-webgl-react
  */
 import React from 'react';
-import * as VIM from '../../core-viewers/webgl/index';
-import { SideState } from '../sidePanel/sideState';
+import * as Core from '../../core-viewers';
+import { SideState } from '../state/sideState';
 export type ToastConfigSpeed = {
     visible: boolean;
     speed: number;
@@ -16,7 +16,7 @@ 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;
+    viewer: Core.Webgl.Viewer;
     side: SideState;
 }): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,5 @@
+export * from './settings';
+export * from './settingsStorage';
+export * from './userBoolean';
+export type * from './menuSettings';
+export type * from './settingsState';

package/dist/types/react-viewers/settings/menuSettings.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.
@@ -11,7 +11,7 @@ import { SettingsState } from './settingsState';
  * @returns
  */
 export declare function MenuSettings(props: {
-    viewer: VIM.Viewer;
+    viewer: Core.Webgl.Viewer;
     settings: SettingsState;
     visible: boolean;
 }): import("react/jsx-runtime").JSX.Element;

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,27 +12,10 @@ 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;
@@ -61,7 +45,9 @@ export type ComponentSettings = {
         pan: UserBoolean;
         zoom: UserBoolean;
         zoomWindow: UserBoolean;
-        zoomToFit: UserBoolean;
+        autoCamera: UserBoolean;
+        frameSelection: UserBoolean;
+        frameScene: UserBoolean;
         sectioningMode: UserBoolean;
         measuringMode: UserBoolean;
         toggleIsolation: UserBoolean;
@@ -74,34 +60,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;