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

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

@@ -1,7 +1,7 @@
-import * as VIM from '../../core-viewers/webgl/index';
-import { LoadingError } from '../webgl/webglLoading';
+import * as Core from '../../core-viewers';
+import { LoadingError } from '../webgl/loading';
 type RequestCallbacks = {
-    onProgress: (p: VIM.IProgressLogs) => void;
+    onProgress: (p: Core.Webgl.IProgressLogs) => void;
     onError: (e: LoadingError) => void;
     onDone: () => void;
 };
@@ -16,14 +16,14 @@ export declare class LoadRequest {
     private _progressPromise;
     private _isDone;
     private _completionPromise;
-    constructor(callbacks: RequestCallbacks, source: VIM.RequestSource, settings?: VIM.VimPartialSettings);
+    constructor(callbacks: RequestCallbacks, source: Core.Webgl.RequestSource, settings?: Core.Webgl.VimPartialSettings);
     private startRequest;
     private onProgress;
     private onSuccess;
     private onError;
     private end;
-    getProgress(): AsyncGenerator<VIM.IProgressLogs, void, void>;
-    getResult(): Promise<import("../../core-viewers/webgl/utils/requestResult").RequestResult<VIM.Vim>>;
+    getProgress(): AsyncGenerator<Core.Webgl.IProgressLogs, void, void>;
+    getResult(): Promise<import("../../utils").Result<Core.Webgl.Vim>>;
     abort(): void;
 }
 export {};

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

@@ -0,0 +1,285 @@
+/**
+ * @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>;
+}
+/**
+ * A basic implementation of StateRef<T> without React.
+ */
+export declare class MutableState<T> implements StateRef<T> {
+    private _value;
+    private _onChange;
+    constructor(initial: T);
+    get(): T;
+    set(value: T): void;
+    confirm(): void;
+    get 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,14 @@
 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 * from './helpers';
+export * from './generic';
+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 { ModalHandle } 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;
@@ -27,8 +37,6 @@ export declare const contextMenuElementIds: {
     showObject: string;
     clearSelection: string;
     showAll: string;
-    dividerMeasure: string;
-    deleteMeasurement: string;
     dividerSection: string;
     ignoreSection: string;
     resetSection: string;
@@ -59,16 +67,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;
-    modal: ModalRef;
-    isolation: Isolation;
-    selection: WebglViewer.Object3D[];
+export declare function ContextMenu(props: {
+    viewer: Core.Webgl.Viewer;
+    camera: CameraRef;
+    modal: ModalHandle;
+    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/help.d.ts

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

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

@@ -0,0 +1,25 @@
+export * as ContextMenu from './contextMenu';
+export declare const SectionBoxPanel: {
+    Ids: {
+        showGhost: string;
+        ghostOpacity: string;
+    };
+};
+export declare const IsolationPanel: {
+    Ids: {
+        topOffset: string;
+        sideOffset: string;
+        bottomOffset: string;
+    };
+};
+export type * from './axesPanel';
+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 './isolationPanel';
+export type * from './restOfScreen';
+export type * from './toast';

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

@@ -0,0 +1,9 @@
+import { IsolationRef } from "../state/sharedIsolation";
+import { GenericPanelHandle } from "../generic/genericPanel";
+export declare const Ids: {
+    showGhost: string;
+    ghostOpacity: string;
+};
+export declare const IsolationPanel: import("react").ForwardRefExoticComponent<{
+    state: IsolationRef;
+} & import("react").RefAttributes<GenericPanelHandle>>;

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

@@ -1,6 +1,7 @@
 /**
  * @module viw-webgl-react
  */
+import { ReactNode } from 'react';
 export type ProgressMode = '%' | 'bytes';
 /**
  * Interface for message information displayed in the LoadingBox.
@@ -12,15 +13,17 @@ export type LoadingBoxProps = {
     message?: string;
     progress?: number;
     mode?: ProgressMode;
+    more?: ReactNode;
 };
 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;
 }): import("react/jsx-runtime").JSX.Element;
+export declare function UltraSuggestion(): import("react/jsx-runtime").JSX.Element;

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,17 @@
+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;
+import { HelpPropsTyped } from './help';
+export type ModalProps = (MessageBoxPropsTyped | LoadingBoxPropsTyped | HelpPropsTyped) & {
+    canClose?: boolean;
     onClose?: () => void;
 };
-export type ModalRef = {
-    current: ModalPropsTyped | undefined;
+export type ModalHandle = {
+    getActiveState(): ModalProps | 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<ModalHandle>>;

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/panels/sectionBoxPanel.d.ts

@@ -1,4 +1,10 @@
 import { SectionBoxRef } from "../state/sectionBoxState";
-export declare function SectionBoxPanel(props: {
+import { GenericPanelHandle } from "../generic/genericPanel";
+export declare const Ids: {
+    topOffset: string;
+    sideOffset: string;
+    bottomOffset: string;
+};
+export declare const SectionBoxPanel: import("react").ForwardRefExoticComponent<{
     state: SectionBoxRef;
-}): import("react/jsx-runtime").JSX.Element;
+} & import("react").RefAttributes<GenericPanelHandle>>;

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 './settingsPanel';
+export type * from './settingsState';