@vertexvis/viewer-toolkit-react 0.0.1

package/dist/state/keybinding/keybinding.d.ts

@@ -0,0 +1,151 @@
+import React from 'react';
+import { EventTargetPredicate } from "@state/keybinding/targets";
+export interface StackKeyBinding {
+    /**
+     * The ID of this stack based key binding.
+     * This ID will be used to match existing actions
+     * on the stack prior to pushing, so it's expected
+     * to be unique to the action. E.g. "CancelMeasurement"
+     * versus a UUID.
+     */
+    id: string;
+    /**
+     * The key binding that will execute the provided
+     * function.
+     *
+     * Supports using a "+" to combine keys, and "||"
+     * to indicate multiple options.
+     *
+     * @example
+     * "Shift+ArrowLeft" -> shift and left arrow pressed
+     * "Shift||ArrowLeft" -> shift or left arrow pressed
+     */
+    keyBind: string;
+    /**
+     * The function to invoke when the `keyBind` matches.
+     */
+    fn: VoidFunction;
+    /**
+     * A predicate that indicates whether to re-add this
+     * key binding when the dependency list changes.
+     * Always re-adds if not specified.
+     */
+    addPredicate?: () => boolean;
+    /**
+     * A predicate that indicates whether to cancel this
+     * key binding when the dependency list changes.
+     * Never cancels if not specified.
+     */
+    cancelPredicate?: () => boolean;
+}
+export interface ApplyKeyBinding {
+    /**
+     * The key binding that will execute the provided
+     * function.
+     *
+     * Supports using a "+" to combine keys, and "||"
+     * to indicate multiple options.
+     *
+     * @example
+     * "Shift+ArrowLeft" -> shift and left arrow pressed
+     * "Shift||ArrowLeft" -> shift or left arrow pressed
+     *
+     * Can be set to undefined to disable the binding.
+     */
+    keyBind?: string;
+    /**
+     * Whether this key binding should repeat
+     */
+    repeat?: boolean;
+    /**
+     * The function to invoke when the `keyBind` matches.
+     * This function should be memoized to avoid infinite rerenders.
+     */
+    fn: VoidFunction;
+    /**
+     * An optional function that is invoked when the `keyBind` no longer
+     * matches.
+     * This function should be memoized to avoid infinite rerenders.
+     */
+    off?: VoidFunction;
+}
+interface StateApplyKeyBinding extends ApplyKeyBinding {
+    id: string;
+    active: boolean;
+}
+export interface KeyBindingState {
+    applyBindings: StateApplyKeyBinding[];
+    bindings: Record<string, StackKeyBinding[]>;
+    pressed: Record<string, boolean>;
+    lastPressed?: string;
+}
+export declare const keyBindings: import("recoil").RecoilState<KeyBindingState>;
+export type KeyBindingAction = {
+    type: 'push-key-binding';
+    binding: StackKeyBinding;
+} | {
+    type: 'remove-key-binding';
+    binding: StackKeyBinding;
+} | {
+    type: 'add-apply-key-binding';
+    binding: StateApplyKeyBinding;
+} | {
+    type: 'remove-apply-key-binding';
+    id: string;
+} | {
+    type: 'set-key-pressed';
+    key: string;
+    pressed: boolean;
+};
+export declare function reducer(state: KeyBindingState, action: KeyBindingAction): KeyBindingState;
+/**
+ * A readonly view of the current key state.
+ */
+export declare const useKeyBindingReadonlyState: () => KeyBindingState;
+/**
+ * Depends on `useKeyBindings`.
+ *
+ * Adds a global key binding. Any key binding
+ * added this way will listen to global state for pressed
+ * keys, and executed whenever the key state matches the
+ * provided `keyBind`.
+ *
+ * @param binding - The `ApplyKeyBinding` to add.
+ */
+export declare const useApplyKeyBinding: (binding: ApplyKeyBinding) => void;
+/**
+ * Depends on `useKeyBindings`.
+ *
+ * Adds a stack-based key binding. Any key binding
+ * added this way will be added to an existing (or new)
+ * stack for the specified `keyBind`.
+ *
+ * Provided `binding`s will be added and cancelled based
+ * on the specified `addPredicate` and `cancelPredicate`
+ * respectively. These predicates are evaluated any time
+ * that the `deps` array changes.
+ *
+ * @param binding - The `StackKeyBinding` to add.
+ * @param deps (optional) - The React dependency list.
+ */
+export declare const useStackKeyBinding: (binding: StackKeyBinding, deps?: React.DependencyList) => void;
+export interface UseKeyBindingsProps {
+    /**
+     * The interval at which to repeat apply keyBinds that have been
+     * created with `repeat` set to `true`.
+     */
+    keydownRepeatInterval?: number;
+    /**
+     * A predicate that indicates whether a keydown should be ignored
+     * based on the event target. Defaults to any `input` like elements.
+     */
+    keydownIgnorePredicate?: EventTargetPredicate;
+}
+/**
+ * Enables key binding usage.
+ *
+ * This hook must appear in the tree for `useStackKeyBinding`
+ * or `useApplyKeyBinding` to work.
+ */
+export declare const useKeyBindings: ({ keydownRepeatInterval, keydownIgnorePredicate, }?: UseKeyBindingsProps) => void;
+export {};

package/dist/state/keybinding/long-press.d.ts

@@ -0,0 +1,7 @@
+export interface UseLongPressProps {
+    target?: HTMLElement | Window;
+    callback?: (event: TouchEvent) => void;
+    delay?: number;
+    onMovement?: () => void;
+}
+export declare function useLongPress({ target, callback, delay, onMovement, }: UseLongPressProps): void;

package/dist/state/keybinding/targets.d.ts

@@ -0,0 +1,2 @@
+export type EventTargetPredicate = (target?: EventTarget | null) => boolean;
+export declare const isInputElement: (target?: EventTarget | null) => boolean;

package/dist/state/performance/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

package/dist/state/performance/types.d.ts

@@ -0,0 +1,37 @@
+export interface Measure {
+    name: string;
+    duration: number;
+    startTime: number;
+}
+export declare const SCENE_ALTERATION_PERFORMANCE = "Scene Alteration Performance";
+export declare enum SceneAlterationPerformanceType {
+    HIDE_ITEM = "Hide Item",
+    SHOW_ONLY_SELECTED = "Show Only Selected",
+    HIDE_SELECTED = "Hide Selected",
+    SHOW_ONLY_ITEM = "Show Only Item",
+    SHOW_ALL = "Show All",
+    HIDE_ALL = "Hide All",
+    SELECT_FILTERED_ITEMS = "Select Filtered Items",
+    INVERT_SELECTION = "Invert Selection",
+    CLEAR_ALL_TRANSFORMS = "Clear All Transforms",
+    CLEAR_SELECTED_TRANSFORMS = "Clear Selected Transforms",
+    CLEAR_SELECTION = "Clear Selection",
+    DESELECTING_ITEMS = "Deselecting Items",
+    SELECTING_ITEMS = "Selecting Items",
+    SELECTING_ONLY_ITEM = "Selecting Only Item",
+    SELECTING_ANCESTOR = "Selecting Ancestor",
+    APPLY_MATERIAL_OVERRIDE_TO_ALL = "Apply Material Override To All",
+    APPLY_MATERIAL_OVERRIDE_TO_SELECTION = "Apply Material Override To Selection",
+    CLEAR_ALL_MATERIAL_OVERRIDES = "Clear All Material Overrides",
+    CLEAR_SELECTED_MATERIAL_OVERRIDES = "Clear Selected Material Overrides",
+    SET_PHANTOM_ALL = "Set Phantom All",
+    SET_PHANTOM_SELECTED_ITEMS = "Set Phantom Selected Items",
+    CLEAR_PHANTOM_ALL = "Clear Phantom All",
+    CLEAR_PHANTOM_SELECTED_ITEMS = "Clear Phantom Selected Items",
+    SET_PHANTOM_NON_SELECTED_ITEMS = "Set Phantom Non Selected Items",
+    RESTORE_PHANTOM_OVERRIDES = "Restore Phantom Overrides",
+    SET_ITEM_AS_END_ITEM = "Set Item as End Item",
+    UNSET_ITEM_AS_END_ITEM = "Unset Item as End Item",
+    SHOW_ANNOTATION = "Show Annotation",
+    HIDE_ANNOTATION = "Hide Annotation"
+}

package/dist/state/scene-tree/columns/columns.d.ts

@@ -0,0 +1,16 @@
+export declare const DEFAULT_NAME_COLUMN: DefaultColumn;
+interface ActiveColumn {
+    initialWidth?: number;
+    minWidth?: number;
+    label: string;
+    binding: string;
+}
+interface DefaultColumn extends ActiveColumn {
+    metadataKeyName: string;
+}
+export interface UseSceneTreeColumnsProps {
+    sceneTreeElement: HTMLVertexSceneTreeElement | null;
+}
+export declare const sceneTreeColumnsActiveColumns: import("recoil").RecoilValueReadOnly<Record<string, ActiveColumn>>;
+export declare const sceneTreeColumnsActiveColumnNames: import("recoil").RecoilValueReadOnly<string[]>;
+export {};

package/dist/state/scene-tree/columns/index.d.ts

@@ -0,0 +1 @@
+export * from './columns';

package/dist/state/scene-tree/core/__tests__/actions.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/state/scene-tree/core/actions.d.ts

@@ -0,0 +1,9 @@
+import type { SceneTreeOperationHandler } from '@vertexvis/viewer/dist/types/components/scene-tree/lib/handlers';
+export interface UseSceneTreeActions {
+    toggleSelection: SceneTreeOperationHandler;
+    toggleExpansion: SceneTreeOperationHandler;
+    toggleVisibility: SceneTreeOperationHandler;
+    flyToRow: (rowClientY: number) => Promise<void>;
+    setContextMenuItem: (rowClientY: number) => Promise<void>;
+}
+export declare function useSceneTreeActions(): UseSceneTreeActions;

package/dist/state/scene-tree/core/core.d.ts

@@ -0,0 +1,5 @@
+import type { SceneTreeController } from '@vertexvis/viewer';
+export declare const sceneTreeLoaderVisible: import("recoil").RecoilState<boolean>;
+export declare const sceneTreeElement: import("recoil").RecoilState<HTMLVertexSceneTreeElement | null | undefined>;
+export declare const sceneTreeWidth: import("recoil").RecoilState<number | undefined>;
+export declare const sceneTreeController: import("recoil").RecoilValueReadOnly<SceneTreeController | undefined>;

package/dist/state/scene-tree/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from './actions';
+export * from './core';

package/dist/state/scene-tree/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

package/dist/state/scene-tree/types.d.ts

@@ -0,0 +1,14 @@
+export declare enum AssemblyFontFace {
+    'ROBOTO' = "ROBOTO",
+    'ROBOTO_MONO' = "ROBOTO_MONO"
+}
+export interface AssemblyFont {
+    fontFace: AssemblyFontFace;
+    color: string;
+}
+export interface AssemblyBackgroundColors {
+    defaultColor: string;
+    depthColors: Record<number, string>;
+    hovered: string;
+    selected: string;
+}

package/dist/state/selection/__tests__/actions.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/state/selection/actions.d.ts

@@ -0,0 +1,25 @@
+import { UUID } from '@vertexvis/utils';
+import { SelectionItem } from './selection';
+export interface SelectOptions {
+    clear?: boolean;
+}
+export interface ClearAndSelectOptions {
+    ignoreAncestorSelection?: boolean;
+}
+export interface SyncSelectionOptions {
+    selected: boolean;
+    multiSelect?: boolean;
+}
+export interface UseSelectionActions {
+    select: (item: SelectionItem, options?: SelectOptions) => void | Promise<void>;
+    toggleSelection: (item: SelectionItem) => void | Promise<void>;
+    clearAndSelect: (item: SelectionItem, options?: ClearAndSelectOptions) => void | Promise<void>;
+    selectCurrentHit: VoidFunction;
+    syncSelection: (item: SelectionItem, options: SyncSelectionOptions) => void | Promise<void>;
+    deselect: (id: UUID.UUID) => void | Promise<void>;
+    clearSelection: () => Promise<void>;
+    resetSelectionState: () => Promise<void>;
+    toggleLastSelectWasMultiSelect: (multiSelection: boolean) => void | Promise<void>;
+    selectForModelViewsPanel: (item?: SelectionItem) => void;
+}
+export declare function useSelectionActions(): UseSelectionActions;

package/dist/state/selection/event-state.d.ts

@@ -0,0 +1,8 @@
+import { UUID } from '@vertexvis/utils';
+import { SelectionItem } from './selection';
+export interface SelectionState {
+    selectedItemIds: UUID.UUID[];
+    lastSelected?: SelectionItem;
+    highestSelectedAncestorId?: UUID.UUID;
+}
+export declare const selectionState: import("recoil").RecoilValueReadOnly<SelectionState>;

package/dist/state/selection/index.d.ts

@@ -0,0 +1,3 @@
+export * from './actions';
+export * from './event-state';
+export * from './selection';

package/dist/state/selection/selection.d.ts

@@ -0,0 +1,16 @@
+import { UUID } from '@vertexvis/utils';
+import type { SceneViewSummary } from '@vertexvis/viewer/dist/types/lib/types';
+export interface SelectionItem {
+    id: UUID.UUID;
+    metadata?: unknown[];
+    ancestors?: string[];
+}
+export declare const selectionSelectedItems: (param: string) => import("recoil").RecoilState<SelectionItem | undefined>;
+export declare const selectionSelectedItemIds: import("recoil").RecoilState<string[]>;
+export declare const selectionLastSelected: import("recoil").RecoilState<SelectionItem | undefined>;
+export declare const selectionLastSelectionFromViewer: import("recoil").RecoilState<boolean>;
+export declare const selectionLastSelectWasMultiSelect: import("recoil").RecoilState<boolean>;
+export declare const selectionHighestSelectedAncestor: import("recoil").RecoilValueReadOnly<string | undefined>;
+export declare const selectionPreviousVisibleSummary: import("recoil").RecoilState<SceneViewSummary.ItemSetSummary | undefined>;
+export declare const selectionVisibleSummary: import("recoil").RecoilState<SceneViewSummary.ItemSetSummary | undefined>;
+export declare const selectionVisibleCount: import("recoil").RecoilValueReadOnly<number>;

package/dist/state/viewer/camera/actions.d.ts

@@ -0,0 +1,7 @@
+import { BoundingBox } from '@vertexvis/geometry';
+export declare const DEFAULT_CAMERA_ANIMATION_DURATION = 500;
+export interface UseViewerCameraActions {
+    flyToById(id: string, animationMs?: number): Promise<void>;
+    flyToByBoundingBox(boundingBox: BoundingBox.BoundingBox, animationMs?: number): Promise<void>;
+}
+export declare function useViewerCameraActions(): UseViewerCameraActions;

package/dist/state/viewer/camera/index.d.ts

@@ -0,0 +1 @@
+export * from './actions';

package/dist/state/viewer/core/core.d.ts

@@ -0,0 +1,5 @@
+import { BaseInteractionHandler, InteractionType } from '@vertexvis/viewer/dist/types/lib/interactions/baseInteractionHandler';
+export declare const viewerElement: import("recoil").RecoilState<HTMLVertexViewerElement | null | undefined>;
+export declare const viewerInitialSceneReady: import("recoil").RecoilState<boolean>;
+export declare const viewerBaseInteractionHandlerProvider: import("recoil").RecoilState<Promise<BaseInteractionHandler | undefined>>;
+export declare const viewerPrimaryInteractionType: import("recoil").RecoilState<InteractionType>;

package/dist/state/viewer/core/index.d.ts

@@ -0,0 +1 @@
+export * from './core';

package/dist/state/viewer/frame/actions.d.ts

@@ -0,0 +1,5 @@
+import { Frame } from '@vertexvis/viewer/dist/types/lib/types';
+export interface UseViewerFrameActions {
+    frameDrawn(event: CustomEvent<Frame>): Promise<void>;
+}
+export declare function useViewerFrameActions(): UseViewerFrameActions;

package/dist/state/viewer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './camera';
+export * from './core';
+export * from './scene';

package/dist/state/viewer/scene/actions.d.ts

@@ -0,0 +1,14 @@
+import { SceneAlterationPerformanceType } from '@state/performance';
+import { UUID } from '@vertexvis/utils';
+import type { SceneItemOperationsBuilder } from '@vertexvis/viewer/dist/types/lib/scenes/index';
+import type { SceneItemQueryExecutor } from '@vertexvis/viewer/dist/types/lib/scenes/queries';
+export type ViewerSceneTransform = (op: SceneItemQueryExecutor) => SceneItemOperationsBuilder;
+export type ViewerSceneItemsTransform = (...ids: UUID.UUID[]) => (op: SceneItemQueryExecutor) => SceneItemOperationsBuilder;
+export interface UseViewerSceneActions {
+    executeWithCorrelationId: (alterationType: SceneAlterationPerformanceType, correlationId: UUID.UUID, ...transforms: ViewerSceneTransform[]) => Promise<void>;
+    execute: (alterationType: SceneAlterationPerformanceType, ...transforms: ViewerSceneTransform[]) => Promise<void>;
+    selectItemsTransform: ViewerSceneItemsTransform;
+    deselectItemsTransform: ViewerSceneItemsTransform;
+    clearSelectionTransform: ViewerSceneTransform;
+}
+export declare function useViewerSceneActions(): UseViewerSceneActions;

package/dist/state/viewer/scene/index.d.ts

@@ -0,0 +1,2 @@
+export * from './actions';
+export * from './scene';

package/dist/state/viewer/scene/item-operations.d.ts

@@ -0,0 +1,11 @@
+import { SceneItemOperationsBuilder, TerminalItemOperationBuilder } from '@vertexvis/viewer/dist/types/lib/scenes';
+export interface SceneItemOperationsProps {
+    viewerElement: HTMLVertexViewerElement | null;
+}
+export interface SceneItemOperations {
+    sceneItemsOperation: (f: (builder: SceneItemOperationsBuilder) => TerminalItemOperationBuilder, ids?: string[]) => Promise<void>;
+    showOnlySelected: () => Promise<void>;
+    showOnlyItem: (id: string) => Promise<void>;
+    hideSelected: () => Promise<void>;
+}
+export declare function useSceneItemsOperations({ viewerElement }: SceneItemOperationsProps): SceneItemOperations;

package/dist/state/viewer/scene/scene.d.ts

@@ -0,0 +1,6 @@
+import { BoundingBox } from '@vertexvis/geometry';
+import type { Scene } from '@vertexvis/viewer';
+import type { FrameScene } from '@vertexvis/viewer/dist/types/lib/types';
+export declare const viewerSceneProvider: import("recoil").RecoilValueReadOnly<() => Promise<Scene | undefined>>;
+export declare const viewerFrameScene: import("recoil").RecoilState<FrameScene | undefined>;
+export declare const viewerSceneVisibleBoundingBox: import("recoil").RecoilValueReadOnly<BoundingBox.BoundingBox | undefined>;

package/dist/testing/__setup__/mocks.d.ts

@@ -0,0 +1,4 @@
+export declare const resizeConstructor: jest.Mock<any, any>;
+export declare const triggerResize: jest.Mock<any, any>;
+export declare const disconnect: jest.Mock<any, any>;
+export declare const observe: jest.Mock<any, any>;

package/dist/testing/additional-hooks-wrapper.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+export interface AdditionalHooksWrapperProps {
+    children: React.ReactNode;
+    hooks: VoidFunction;
+}
+/**
+ * A small wrapper component that allows for rendering
+ * of arbitrary hooks, provided by the `hooks` prop. This
+ * allows for "global" hooks to be included when testing
+ * a smaller component.
+ *
+ * Example rendering with keybindings present:
+ *
+ * <AdditionalHooksWrapper hooks={() => useKeyBindings()}>
+ *   <BoxSelectionEnableTool />
+ * </AdditionalHooksWrapper>
+ *
+ */
+export declare function AdditionalHooksWrapper({ children, hooks, }: AdditionalHooksWrapperProps): JSX.Element;

package/dist/testing/react.d.ts

@@ -0,0 +1,13 @@
+export interface DefinedRefObject<T> extends React.RefObject<T> {
+    current: T;
+}
+/**
+ * Filters out any props (provided as {...props} when mocking elements)
+ * that are not supported to reduce the amount of error logging during tests.
+ */
+export declare function filterAttributes(props: Record<string, unknown>, additionalSupportedKeys?: string[]): Record<string, unknown>;
+/**
+ * Retrieves an attribute from an element that has been mocked in the
+ * `mocks.tsx` setup file.
+ */
+export declare function getTestAttribute(element: HTMLElement, attribute: string): string | undefined;

package/dist/testing/recoil-observer.d.ts

@@ -0,0 +1,6 @@
+import { RecoilState } from 'recoil';
+export interface RecoilObserverProps<T> {
+    node: RecoilState<T>;
+    onChange: jest.Mock;
+}
+export declare function RecoilObserver<T>({ node, onChange, }: RecoilObserverProps<T>): JSX.Element;

package/dist/testing/recoil-state.d.ts

@@ -0,0 +1,5 @@
+import { MutableSnapshot } from 'recoil';
+import { ViewerRefMock } from './viewer';
+export declare const initializeViewerElementProvider: (snapshot: MutableSnapshot, viewerRefMock: ViewerRefMock) => void;
+export declare const initializeViewerSceneCamera: (snapshot: MutableSnapshot, viewerRefMock: ViewerRefMock) => void;
+export declare const initializeViewerProviders: (snapshot: MutableSnapshot, viewerRefMock: ViewerRefMock) => void;

package/dist/testing/recoil-wrapper.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { MutableSnapshot } from 'recoil';
+interface Props extends Record<string, unknown> {
+    children?: React.ReactNode;
+    initializeState?: (snapshot: MutableSnapshot) => void;
+}
+interface ObservableProps extends Props {
+    observers?: React.ReactElement[];
+}
+interface RenderHookOptions<T> {
+    wrapper: (props: T) => React.ReactElement<T>;
+}
+export declare const ObservableRecoilWrapper: ({ children, initializeState, observers, }: ObservableProps) => React.ReactElement<ObservableProps>;
+export declare const RecoilWrapper: ({ children, initializeState, }: Props) => React.ReactElement<Props>;
+export declare const renderHookOptions: {
+    wrapper: ({ children, initializeState, }: Props) => React.ReactElement<Props>;
+};
+export type ObservableRenderHookOptions = RenderHookOptions<ObservableProps>;
+export declare const createObservableRenderHookOptionsWithInitialState: (initializeState?: (snapshot: MutableSnapshot) => void, ...observers: React.ReactElement[]) => ObservableRenderHookOptions;
+export declare const createObservableRenderHookOptions: (...observers: React.ReactElement[]) => ObservableRenderHookOptions;
+export {};

package/dist/testing/viewer.d.ts

@@ -0,0 +1,72 @@
+import { BoundingBox, Vector3 } from '@vertexvis/geometry';
+import type { SceneItemOperationsBuilder } from '@vertexvis/viewer/dist/types/lib/scenes';
+import type { RootQuery } from '@vertexvis/viewer/dist/types/lib/scenes/queries';
+import { DefinedRefObject } from './react';
+export declare const boundingBox: BoundingBox.BoundingBox;
+export interface ViewerRefMock {
+    ref: DefinedRefObject<HTMLVertexViewerElement>;
+    items: jest.Mock;
+    raycaster: jest.Mock;
+    hitItems: jest.Mock;
+    crossSectioning: CrossSectioningMockObject;
+    applySceneViewState: jest.Mock;
+    applyPartialSceneViewState: jest.Mock;
+    camera: CameraMockObject;
+    viewport: ViewportMockObject;
+    execute: jest.Mock;
+    where: jest.Mock;
+    reset: jest.Mock;
+    query: RootQuery;
+    op: Pick<SceneItemOperationsBuilder, 'show' | 'hide' | 'select' | 'deselect' | 'materialOverride' | 'clearMaterialOverrides' | 'transform' | 'clearTransforms' | 'setPhantom' | 'clearPhantom'>;
+    setPrimaryInteractionType: jest.Mock;
+    getPrimaryInteractionType: jest.Mock;
+}
+export interface ViewportMockObject {
+    width: number;
+    height: number;
+    transformWorldToViewport: jest.Mock;
+}
+export interface CameraMockObject {
+    root: jest.Mock;
+    viewAll: jest.Mock;
+    fitToBoundingBox: jest.Mock;
+    distanceToBoundingBoxCenter: jest.Mock;
+    flyTo: jest.Mock;
+    moveBy: jest.Mock;
+    render: jest.Mock;
+    rotateAroundAxis: jest.Mock;
+    rotateAroundAxisAtPoint: jest.Mock;
+    alignTo: jest.Mock;
+    update: jest.Mock;
+    viewVector: Vector3.Vector3;
+    position: Vector3.Vector3;
+    up: Vector3.Vector3;
+    lookAt: Vector3.Vector3;
+    fovY: number;
+    aspectRatio: number;
+    near: number;
+    far: number;
+}
+export interface CrossSectioningMockObject {
+    root: jest.Mock;
+    update: jest.Mock;
+    current: jest.Mock;
+}
+export interface MockHit {
+    itemId: {
+        hex: string;
+    };
+    hitNormal?: Vector3.Vector3;
+    hitPosition?: Vector3.Vector3;
+    hitPoint?: Vector3.Vector3;
+    ancestors?: Array<{
+        itemId: {
+            hex: string;
+        };
+    }>;
+}
+export interface ViewerRefMockInitializationProps {
+    hits?: MockHit[];
+}
+export declare const notWithSelected: jest.Mock<any, any>;
+export declare function createViewerRefMock(hits?: MockHit[], frame?: unknown): ViewerRefMock;

package/dist/util/camera/__tests__/camera.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/util/camera/camera.d.ts

@@ -0,0 +1,3 @@
+import { BoundingBox, Vector3 } from '@vertexvis/geometry';
+import { Camera } from '@vertexvis/viewer';
+export declare const alignToNormal: (camera: Camera, normal: Vector3.Vector3, boundingBox: BoundingBox.BoundingBox) => Camera;

package/dist/util/cross-section/__tests__/interaction-handler.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/util/cross-section/__tests__/section-plane.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/util/cross-section/interaction-handler.d.ts

@@ -0,0 +1,10 @@
+import type { InteractionHandler } from '@vertexvis/viewer';
+import type { InteractionApi } from '@vertexvis/viewer/dist/types/lib/interactions/interactionApi';
+export declare class CrossSectionInteractionHandler implements InteractionHandler {
+    private api?;
+    private interactionStarted;
+    initialize(element: HTMLElement, api: InteractionApi): void;
+    dispose(): void;
+    beginInteraction(): Promise<void>;
+    endInteraction(): Promise<void>;
+}

package/dist/util/cross-section/section-plane.d.ts

@@ -0,0 +1,61 @@
+import { Hit } from '@state/hits';
+import { BoundingBox, Vector3 } from '@vertexvis/geometry';
+import type { Camera } from '@vertexvis/viewer/dist/types/lib/scenes';
+export interface OffsetRange {
+    min: number;
+    max: number;
+}
+export interface CrossSectionPlane {
+    normal: Vector3.Vector3;
+    offset: number;
+}
+export type CrossSectionPlaneAxes = CustomCrossSectionPlaneAxes | DefaultCrossSectionPlaneAxes;
+interface CustomCrossSectionPlaneAxes {
+    x: Vector3.Vector3;
+    y?: Vector3.Vector3;
+    z?: Vector3.Vector3;
+}
+interface DefaultCrossSectionPlaneAxes {
+    x: Vector3.Vector3;
+    y: Vector3.Vector3;
+    z: Vector3.Vector3;
+}
+export type Axis = 'x' | 'y' | 'z';
+export type CrossSectionAlignment = 'global' | 'surface' | 'part';
+export declare const create: (normal: Vector3.Vector3, offset?: number) => CrossSectionPlane;
+export declare const isEqual: (plane: CrossSectionPlane, other: CrossSectionPlane) => boolean;
+export declare const forAxis: (axis: Axis, offset: number) => CrossSectionPlane;
+export declare const x: (offset: number) => CrossSectionPlane;
+export declare const y: (offset: number) => CrossSectionPlane;
+export declare const z: (offset: number) => CrossSectionPlane;
+export declare const getAxis: (axis: Axis, axes: CrossSectionPlaneAxes) => Vector3.Vector3;
+export declare const defaultAxes: DefaultCrossSectionPlaneAxes;
+export declare const xAxis: (axes: CrossSectionPlaneAxes) => Vector3.Vector3;
+export declare const yAxis: (axes: CrossSectionPlaneAxes) => Vector3.Vector3;
+export declare const zAxis: (axes: CrossSectionPlaneAxes) => Vector3.Vector3;
+/**
+ * Returns the active axis of a plane based on the normal values
+ */
+export declare const axis: (plane: CrossSectionPlane, xAxis: Vector3.Vector3, yAxis: Vector3.Vector3, zAxis: Vector3.Vector3) => Axis | undefined;
+export declare const isNegativeNormal: (plane: CrossSectionPlane) => boolean | undefined;
+/**
+ * Returns an updated section plane where the normal of the section plane is
+ * faced towards the given vector. The effect is the internal of the cross
+ * section is visible from the given vector.
+ */
+export declare const towardsVector: (vector: Vector3.Vector3, plane: CrossSectionPlane) => CrossSectionPlane;
+/**
+ * Returns an updated section plane where the normal of the section plane is
+ * faced towards given camera's view vector. The effect is the user sees the
+ * internal of the cross section.
+ */
+export declare const towardsCamera: (camera: Camera, plane: CrossSectionPlane) => CrossSectionPlane;
+/**
+ * Reverses the direction of the section plane's normal to point in the opposite
+ * direction.
+ */
+export declare const invert: (plane: CrossSectionPlane) => CrossSectionPlane;
+export declare const fromHit: (hit: Hit, camera: Camera) => CrossSectionPlane;
+export declare const toAxis: (axis: Axis, axes: CrossSectionPlaneAxes, camera: Camera, boundingBox?: BoundingBox.BoundingBox, position?: Vector3.Vector3) => CrossSectionPlane;
+export declare function axesFromPlane(plane: CrossSectionPlane): CrossSectionPlaneAxes;
+export {};