@cognite/reveal-components 1.0.0

package/dist/ui/components/SceneContainer/LoadedSceneContext.js

@@ -0,0 +1,22 @@
+import { useRevealKeepAlive as e } from "../RevealKeepAlive/RevealKeepAliveContext.js";
+import { createContext as t, useCallback as n, useContext as r, useMemo as i, useState as a } from "react";
+import { jsx as o } from "react/jsx-runtime";
+//#region libs/shared/reveal-components/src/ui/components/SceneContainer/LoadedSceneContext.tsx
+var s = t(void 0), c = ({ children: t }) => {
+	let [r, c] = a(void 0), l = e(), u = n((e) => {
+		l !== void 0 && (l.sceneLoadedRef.current = e), c(e);
+	}, [l]), d = i(() => l?.sceneLoadedRef.current ?? r, [r, l]);
+	return /* @__PURE__ */ o(s.Provider, {
+		value: {
+			loadedScene: d,
+			setScene: u
+		},
+		children: t
+	});
+}, l = () => {
+	let e = r(s);
+	if (e === void 0) throw Error("useLoadedScene must be used within a LoadedSceneProvider");
+	return e;
+};
+//#endregion
+export { c as LoadedSceneProvider, l as useLoadedScene };

package/dist/ui/components/SceneContainer/SceneContainer.context.d.ts

@@ -0,0 +1,9 @@
+import { Context } from 'react';
+import { Reveal3DResources } from '../Reveal3DResources/Reveal3DResources';
+import { useSceneContainerViewModel } from './SceneContainer.viewmodel';
+export type SceneContainerDependencies = {
+    Reveal3DResources: typeof Reveal3DResources;
+    useSceneContainerViewModel: typeof useSceneContainerViewModel;
+};
+export declare const defaultSceneContainerDependencies: SceneContainerDependencies;
+export declare const SceneContainerContext: Context<SceneContainerDependencies>;

package/dist/ui/components/SceneContainer/SceneContainer.context.js

@@ -0,0 +1,10 @@
+import { Reveal3DResources as e } from "../Reveal3DResources/Reveal3DResources.js";
+import { useSceneContainerViewModel as t } from "./SceneContainer.viewmodel.js";
+import { createContext as n } from "react";
+//#region libs/shared/reveal-components/src/ui/components/SceneContainer/SceneContainer.context.tsx
+var r = {
+	Reveal3DResources: e,
+	useSceneContainerViewModel: t
+}, i = n(r);
+//#endregion
+export { i as SceneContainerContext, r as defaultSceneContainerDependencies };

package/dist/ui/components/SceneContainer/SceneContainer.d.ts

@@ -0,0 +1,3 @@
+import { ReactNode } from 'react';
+import { SceneContainerProps } from './types';
+export declare function SceneContainer({ sceneExternalId, sceneSpaceId, onResourcesAdded, ...rest }: SceneContainerProps): ReactNode;

package/dist/ui/components/SceneContainer/SceneContainer.js

@@ -0,0 +1,19 @@
+import { SceneContainerContext as e } from "./SceneContainer.context.js";
+import { useCallback as t, useContext as n } from "react";
+import { jsx as r } from "react/jsx-runtime";
+//#region libs/shared/reveal-components/src/ui/components/SceneContainer/SceneContainer.tsx
+function i({ sceneExternalId: i, sceneSpaceId: a, onResourcesAdded: o, ...s }) {
+	let { Reveal3DResources: c, useSceneContainerViewModel: l } = n(e), { resourceOptions: u, hasResources: d, onApplySettingsFromScene: f } = l({
+		sceneExternalId: i,
+		sceneSpaceId: a
+	}), p = t(() => {
+		f(), o?.();
+	}, [f, o]);
+	return d ? /* @__PURE__ */ r(c, {
+		resources: u,
+		onResourcesAdded: p,
+		...s
+	}) : null;
+}
+//#endregion
+export { i as SceneContainer };

package/dist/ui/components/SceneContainer/SceneContainer.viewmodel.context.d.ts

@@ -0,0 +1,15 @@
+import { Context } from 'react';
+import { useGroundPlaneFromScene } from '../../hooks/useGroundPlaneFromScene';
+import { useReveal3dResourcesFromScene } from '../../hooks/useReveal3dResourcesFromScene';
+import { useSkyboxFromScene } from '../../hooks/useSkyboxFromScene';
+import { useLoadPoisForScene } from '../commandBased/pointsOfInterest/useLoadPoisForScene';
+import { useQualitySettingsFromScene } from './hooks/useQualitySettingsFromScene';
+export type SceneContainerViewModelDependencies = {
+    useReveal3dResourcesFromScene: typeof useReveal3dResourcesFromScene;
+    useGroundPlaneFromScene: typeof useGroundPlaneFromScene;
+    useSkyboxFromScene: typeof useSkyboxFromScene;
+    useLoadPoisForScene: typeof useLoadPoisForScene;
+    useQualitySettingsFromScene: typeof useQualitySettingsFromScene;
+};
+export declare const defaultSceneContainerViewModelDependencies: SceneContainerViewModelDependencies;
+export declare const SceneContainerViewModelContext: Context<SceneContainerViewModelDependencies>;

package/dist/ui/components/SceneContainer/SceneContainer.viewmodel.context.js

@@ -0,0 +1,16 @@
+import { useGroundPlaneFromScene as e } from "../../hooks/useGroundPlaneFromScene.js";
+import { useReveal3dResourcesFromScene as t } from "../../hooks/useReveal3dResourcesFromScene.js";
+import { useSkyboxFromScene as n } from "../../hooks/useSkyboxFromScene.js";
+import { useLoadPoisForScene as r } from "../commandBased/pointsOfInterest/useLoadPoisForScene.js";
+import { useQualitySettingsFromScene as i } from "./hooks/useQualitySettingsFromScene.js";
+import { createContext as a } from "react";
+//#region libs/shared/reveal-components/src/ui/components/SceneContainer/SceneContainer.viewmodel.context.ts
+var o = {
+	useReveal3dResourcesFromScene: t,
+	useGroundPlaneFromScene: e,
+	useSkyboxFromScene: n,
+	useLoadPoisForScene: r,
+	useQualitySettingsFromScene: i
+}, s = a(o);
+//#endregion
+export { s as SceneContainerViewModelContext, o as defaultSceneContainerViewModelDependencies };

package/dist/ui/components/SceneContainer/SceneContainer.viewmodel.d.ts

@@ -0,0 +1,2 @@
+import { UseSceneContainerViewModelProps, UseSceneContainerViewModelResult } from './types';
+export declare function useSceneContainerViewModel({ sceneExternalId, sceneSpaceId, }: UseSceneContainerViewModelProps): UseSceneContainerViewModelResult;

package/dist/ui/components/SceneContainer/SceneContainer.viewmodel.js

@@ -0,0 +1,15 @@
+import { SceneContainerViewModelContext as e } from "./SceneContainer.viewmodel.context.js";
+import { useContext as t, useMemo as n } from "react";
+//#region libs/shared/reveal-components/src/ui/components/SceneContainer/SceneContainer.viewmodel.tsx
+function r({ sceneExternalId: r, sceneSpaceId: i }) {
+	let { useReveal3dResourcesFromScene: a, useGroundPlaneFromScene: o, useSkyboxFromScene: s, useLoadPoisForScene: c, useQualitySettingsFromScene: l } = t(e), u = a(r, i);
+	o(r, i), s(r, i), c(r, i);
+	let { onApplySettingsFromScene: d } = l(r, i);
+	return {
+		resourceOptions: u,
+		hasResources: n(() => u.length > 0, [u]),
+		onApplySettingsFromScene: d
+	};
+}
+//#endregion
+export { r as useSceneContainerViewModel };

package/dist/ui/components/SceneContainer/SceneFdmTypes.d.ts

@@ -0,0 +1,103 @@
+export type NodeResponse = {
+    instanceType: string;
+    version: number;
+    space: string;
+    externalId: string;
+};
+export type EdgeResponse = {
+    version: number;
+    type: {
+        space: string;
+        externalId: string;
+    };
+    space: string;
+    externalId: string;
+    startNode: {
+        space: string;
+        externalId: string;
+    };
+    endNode: {
+        space: string;
+        externalId: string;
+    };
+};
+export type SceneResponse = {
+    items: {
+        myScene: SceneConfigurationResponse[];
+        skybox: SkyboxResponse[];
+        groundPlanes: GroundPlaneResponse[];
+        groundPlaneEdges: GroundPlaneEdgeResponse[];
+        sceneModels: SceneModelsResponse[];
+        image360CollectionsEdges: Image360CollectionsResponse[];
+    };
+    nextCursor?: {
+        myScene: string;
+        skybox: string;
+    };
+};
+export type Transformation3d = {
+    translationX: number;
+    translationY: number;
+    translationZ: number;
+    eulerRotationX: number;
+    eulerRotationY: number;
+    eulerRotationZ: number;
+    scaleX: number;
+    scaleY: number;
+    scaleZ: number;
+};
+export type SceneConfigurationResponse = NodeResponse & {
+    properties: Record<string, Record<string, SceneConfigurationProperties>>;
+};
+export type SkyboxResponse = NodeResponse & {
+    properties: Record<string, Record<string, SkyboxProperties>>;
+};
+export type SceneModelsResponse = EdgeResponse & {
+    properties: Record<string, Record<string, SceneModelsProperties>>;
+};
+export type SceneModelsProperties = Transformation3d & {
+    revisionId: number;
+    defaultVisible?: boolean;
+};
+export type Image360CollectionsResponse = EdgeResponse & {
+    properties: Record<string, Record<string, Scene360ImageCollectionsProperties>>;
+};
+export type Scene360ImageCollectionsProperties = Transformation3d & {
+    image360CollectionExternalId: string;
+    image360CollectionSpace: string;
+    defaultVisible?: boolean;
+};
+export type SceneConfigurationProperties = {
+    name: string;
+    cameraTranslationX: number;
+    cameraTranslationY: number;
+    cameraTranslationZ: number;
+    cameraEulerRotationX: number;
+    cameraEulerRotationY: number;
+    cameraEulerRotationZ: number;
+    cadBudget?: number;
+    pointCloudBudget?: number;
+    maxRenderResolution?: number;
+    movingCameraResolutionFactor?: number;
+    pointCloudPointSize?: number;
+    pointCloudPointShape?: string;
+    pointCloudColor?: string;
+};
+export type SkyboxProperties = {
+    label: string;
+    isSpherical: boolean;
+    file: string;
+};
+export type GroundPlaneResponse = NodeResponse & {
+    properties: Record<string, Record<string, GroundPlaneProperties>>;
+};
+export type GroundPlaneProperties = {
+    file: string;
+    label: string;
+    wrapping: string;
+    repeatU?: number;
+    repeatV?: number;
+};
+export type GroundPlaneEdgeResponse = EdgeResponse & {
+    properties: Record<string, Record<string, Transformation3d>>;
+};

package/dist/ui/components/SceneContainer/hooks/useQualitySettingsFromScene.context.d.ts

@@ -0,0 +1,11 @@
+import { Context } from 'react';
+import { useRenderTarget } from '../../RevealCanvas';
+import { Scene } from '../sceneTypes';
+export type UseQualitySettingsFromSceneDependencies = {
+    useSceneConfig: (sceneExternalId: string, sceneSpaceId: string) => {
+        data: Scene | null | undefined;
+    };
+    useRenderTarget: typeof useRenderTarget;
+};
+export declare const defaultUseQualitySettingsFromSceneDependencies: UseQualitySettingsFromSceneDependencies;
+export declare const UseQualitySettingsFromSceneContext: Context<UseQualitySettingsFromSceneDependencies>;

package/dist/ui/components/SceneContainer/hooks/useQualitySettingsFromScene.context.js

@@ -0,0 +1,11 @@
+import { useRenderTarget as e } from "../../RevealCanvas/ViewerContext.js";
+import "../../RevealCanvas/index.js";
+import { useSceneConfig as t } from "../../../hooks/scenes/useSceneConfig.js";
+import { createContext as n } from "react";
+//#region libs/shared/reveal-components/src/ui/components/SceneContainer/hooks/useQualitySettingsFromScene.context.ts
+var r = {
+	useSceneConfig: t,
+	useRenderTarget: e
+}, i = n(r);
+//#endregion
+export { i as UseQualitySettingsFromSceneContext, r as defaultUseQualitySettingsFromSceneDependencies };

package/dist/ui/components/SceneContainer/hooks/useQualitySettingsFromScene.d.ts

@@ -0,0 +1,5 @@
+type UseQualitySettingsFromSceneResult = {
+    onApplySettingsFromScene: () => void;
+};
+export declare const useQualitySettingsFromScene: (sceneExternalId: string, sceneSpaceId: string) => UseQualitySettingsFromSceneResult;
+export {};

package/dist/ui/components/SceneContainer/hooks/useQualitySettingsFromScene.js

@@ -0,0 +1,16 @@
+import { applyQualitySettingsToRenderTarget as e, applyResourceSettings as t } from "../../../../utilities/resourceSettings.js";
+import { UseQualitySettingsFromSceneContext as n } from "./useQualitySettingsFromScene.context.js";
+import { useCallback as r, useContext as i, useEffect as a } from "react";
+//#region libs/shared/reveal-components/src/ui/components/SceneContainer/hooks/useQualitySettingsFromScene.tsx
+var o = (o, s) => {
+	let { useSceneConfig: c, useRenderTarget: l } = i(n), { data: u } = c(o, s), d = l();
+	return a(() => {
+		let t = u?.sceneConfiguration.qualitySettings;
+		t !== void 0 && e(d, t);
+	}, [u?.sceneConfiguration.qualitySettings, d]), { onApplySettingsFromScene: r(() => {
+		let e = u?.sceneConfiguration.qualitySettings;
+		e !== void 0 && t(d.revealSettingsController, e);
+	}, [u?.sceneConfiguration.qualitySettings, d]) };
+};
+//#endregion
+export { o as useQualitySettingsFromScene };

package/dist/ui/components/SceneContainer/index.d.ts

@@ -0,0 +1,4 @@
+export { SceneContainer } from './SceneContainer';
+export type { SceneContainerProps } from './types';
+export type { SceneIdentifiers } from './sceneTypes';
+export { useLoadedScene } from './LoadedSceneContext';

package/dist/ui/components/SceneContainer/index.js

@@ -0,0 +1,3 @@
+import { useLoadedScene as e } from "./LoadedSceneContext.js";
+import { SceneContainer as t } from "./SceneContainer.js";
+export { t as SceneContainer, e as useLoadedScene };

package/dist/ui/components/SceneContainer/sceneTypes.d.ts

@@ -0,0 +1,69 @@
+import { Transformation3d } from './SceneFdmTypes';
+export type Scene = {
+    sceneConfiguration: SceneConfiguration;
+    skybox: Skybox | undefined;
+    groundPlanes: GroundPlane[];
+    sceneModels: CadOrPointCloudModel[];
+    image360Collections: Image360Collection[];
+};
+export type SceneConfiguration = {
+    name: string;
+    cameraTranslationX: number;
+    cameraTranslationY: number;
+    cameraTranslationZ: number;
+    cameraEulerRotationX: number;
+    cameraEulerRotationY: number;
+    cameraEulerRotationZ: number;
+    cameraTargetX?: number;
+    cameraTargetY?: number;
+    cameraTargetZ?: number;
+    updatedAt?: string;
+    qualitySettings?: SceneQualitySettings;
+};
+export type SceneQualitySettings = {
+    cadBudget?: number;
+    pointCloudBudget?: number;
+    maxRenderResolution?: number;
+    movingCameraResolutionFactor?: number;
+    pointCloudPointSize?: number;
+    pointCloudPointShape?: string;
+    pointCloudColor?: string;
+    image360Transparency?: number;
+    image360MarkerAlpha?: number;
+    image360MarkerVisible?: boolean;
+    image360XRay?: boolean;
+};
+export type ClassicModelIdentifier = {
+    modelId: number;
+    revisionId: number;
+};
+export type DMModelIdenfitier = {
+    revisionExternalId: string;
+    revisionSpace: string;
+};
+export type ModelIdentifier = ClassicModelIdentifier | DMModelIdenfitier;
+export type CadOrPointCloudModel = Transformation3d & {
+    modelIdentifier: ModelIdentifier;
+    defaultVisible?: boolean;
+};
+export type Image360Collection = Transformation3d & {
+    image360CollectionExternalId: string;
+    image360CollectionSpace: string;
+    defaultVisible?: boolean;
+};
+export type Skybox = {
+    label: string;
+    isSpherical: boolean;
+    file: string;
+};
+export type GroundPlane = Transformation3d & {
+    file: string;
+    label: string;
+    wrapping: string;
+    repeatU: number;
+    repeatV: number;
+};
+export type SceneIdentifiers = {
+    externalId: string;
+    spaceId: string;
+};

package/dist/ui/components/SceneContainer/types.d.ts

@@ -0,0 +1,15 @@
+import { AddReveal3DResource } from '../../../data-providers/types/resources';
+import { CommonResourceContainerProps } from '../../../utilities/modelIds/types';
+export type SceneContainerProps = {
+    sceneExternalId: string;
+    sceneSpaceId: string;
+} & CommonResourceContainerProps;
+export type UseSceneContainerViewModelProps = {
+    sceneExternalId: string;
+    sceneSpaceId: string;
+};
+export type UseSceneContainerViewModelResult = {
+    resourceOptions: AddReveal3DResource[];
+    hasResources: boolean;
+    onApplySettingsFromScene: () => void;
+};

package/dist/ui/components/ViewerAnchor/ViewerAnchor.d.ts

@@ -0,0 +1,12 @@
+import { CSSProperties, ReactNode } from 'react';
+import { Vector3 } from 'three';
+type ViewerAnchorStyle = Omit<CSSProperties, 'position' | 'left' | 'top'>;
+export type ViewerAnchorProps = {
+    position: Vector3;
+    sticky?: boolean;
+    stickyMargin?: number;
+    style?: ViewerAnchorStyle;
+    children: ReactNode;
+};
+export declare const ViewerAnchor: ({ position: position3d, children, style: inputStyle, sticky, stickyMargin: inputStickyMargin, }: ViewerAnchorProps) => ReactNode;
+export {};

package/dist/ui/components/ViewerAnchor/ViewerAnchor.js

@@ -0,0 +1,60 @@
+import { useReveal as e } from "../RevealCanvas/ViewerContext.js";
+import { useCallback as t, useEffect as n, useRef as r, useState as i } from "react";
+import { clamp as a } from "lodash-es";
+import { Fragment as o, jsx as s } from "react/jsx-runtime";
+import { Vector2 as c } from "three";
+//#region libs/shared/reveal-components/src/ui/components/ViewerAnchor/ViewerAnchor.tsx
+var l = ({ position: t, children: n, style: i, sticky: a, stickyMargin: c }) => {
+	let l = e(), f = c ?? 0, { projectedPoint: m, visible: h } = u(t, l), g = r(null), _ = p(m, d(g, l.domElement, a ?? !1, f, m), i);
+	return h ? /* @__PURE__ */ s("div", {
+		ref: g,
+		style: {
+			..._,
+			position: "absolute",
+			left: "0px",
+			top: "0px"
+		},
+		children: n
+	}) : /* @__PURE__ */ s(o, {});
+};
+function u(e, r) {
+	let [a, o] = i(new c()), [s, l] = i(!1), u = t((t, n) => {
+		let i = n.clone().sub(t).normalize(), a = e.clone().sub(t).normalize();
+		l(a.dot(i) > 0);
+		let s = r.worldToScreen(e.clone());
+		s !== null && o(s);
+	}, [r, e]);
+	return n(() => (r.cameraManager.on("cameraChange", u), u(r.cameraManager.getCameraState().position, r.cameraManager.getCameraState().target), () => {
+		r.cameraManager.off("cameraChange", u);
+	}), [u]), {
+		visible: s,
+		projectedPoint: a
+	};
+}
+function d(e, t, r, a, o) {
+	let [s, l] = i(new c());
+	return n(() => {
+		if (r && e.current !== null) {
+			let n = f(e.current.getBoundingClientRect(), t.getBoundingClientRect(), s, a);
+			n.equals(s) || l(n);
+		} else l(new c());
+	}, [
+		o.x,
+		o.y,
+		r,
+		a,
+		t.clientWidth,
+		t.clientHeight
+	]), s;
+}
+function f(e, t, n, r) {
+	let i = n.clone(), o = new DOMRect(e.left - t.left - n.x, e.top - t.top - n.y, e.width, e.height), s = r, c = t.width - o.width - r, l = r, u = t.height - o.height - r;
+	return i.x = a(0, s - o.left, c - o.left), i.y = a(0, l - o.top, u - o.top), Math.min(c - o.left, Math.max(s - o.left, 0)), i;
+}
+function p(e, t, n) {
+	let r = `translateX(calc(${e.x}px + ${t.x}px))
+translateY(calc(${e.y}px + ${t.y}px))`, i = { ...n };
+	return i.transform = `${i.transform ?? ""} ${r}`, i;
+}
+//#endregion
+export { l as ViewerAnchor };

package/dist/ui/components/Widget/RevealWidget.context.d.ts

@@ -0,0 +1,15 @@
+import { Context } from 'react';
+import { RevealRenderTarget } from '../../../domains';
+import { RevealCanvas, useRenderTarget } from '../RevealCanvas';
+import { RevealContext } from '../RevealContext';
+import { RevealWidgetController } from './RevealWidgetController';
+type RevealWidgetFactory = (renderTarget: RevealRenderTarget) => RevealWidgetController;
+export type RevealWidgetDependencies = {
+    createRevealWidgetController: RevealWidgetFactory;
+    RevealCanvas: typeof RevealCanvas;
+    RevealContext: typeof RevealContext;
+    useRenderTarget: typeof useRenderTarget;
+};
+export declare const defaultRevealWidgetDependencies: RevealWidgetDependencies;
+export declare const RevealWidgetContext: Context<RevealWidgetDependencies>;
+export {};

package/dist/ui/components/Widget/RevealWidget.context.js

@@ -0,0 +1,16 @@
+import { useRenderTarget as e } from "../RevealCanvas/ViewerContext.js";
+import { RevealCanvas as t } from "../RevealCanvas/RevealCanvas.js";
+import "../RevealCanvas/index.js";
+import { RevealContext as n } from "../RevealContext/RevealContext.js";
+import "../RevealContext/index.js";
+import { RevealWidgetController as r } from "./RevealWidgetController.js";
+import { createContext as i } from "react";
+//#region libs/shared/reveal-components/src/ui/components/Widget/RevealWidget.context.ts
+var a = {
+	createRevealWidgetController: (e) => new r(e),
+	RevealCanvas: t,
+	RevealContext: n,
+	useRenderTarget: e
+}, o = i(a);
+//#endregion
+export { o as RevealWidgetContext, a as defaultRevealWidgetDependencies };

package/dist/ui/components/Widget/RevealWidget.d.ts

@@ -0,0 +1,62 @@
+import { PropsWithChildren, ReactElement } from 'react';
+import { Cognite3DViewerOptions } from '@cognite/reveal';
+import { RevealWidgetController } from './RevealWidgetController';
+/**
+ * React-properties for the RevealWidget
+ */
+export type RevealWidgetProps = {
+    /**
+     * Defines the initialization options for the RevealWidget, including the SDK and data modeling status
+     * The user can either specify these separately, or opt for the object
+     * `{ inheritFromRevealContext: true }`, in which case the Widget will assume the existence of
+     * a `RevealContext` mounted above it in the hierarchy.
+     */
+    viewerOptions: (Pick<Cognite3DViewerOptions, 'sdk' | 'onLoading'> & {
+        useCoreDm: boolean;
+    }) | {
+        /**
+         * Disables the RevealWidget's own RevealContext, relying on one defined in the application
+         * layer instead.
+         */
+        inheritFromRevealContext: true;
+    };
+    /**
+     * The widget uses this to set a reference to the widget controller.
+     * The widget calls this with `undefined` when the component unmounts or this callback changes
+     */
+    setControllerRef?: (controller: RevealWidgetController | undefined) => void;
+};
+/**
+ * RevealWidget component - the React entry point for the Reveal Widget.
+ * An example with some custom UI components:
+ * ```
+ *       <RevealWidget setControllerRef={setControllerRef} viewerOptions={{ sdk, useCoreDm: true }}>
+ *         <RevealToolbar
+ *           toolBarContent={
+ *             <CommandButtons
+ *               placement="left"
+ *               commands={[
+ *                 new ShowLayersCommand(),
+ *                 new FitViewCommand(),
+ *                 new MeasurementTool(),
+ *                 new ClipTool(),
+ *                 new SettingsCommand(),
+ *               ]}
+ *             />
+ *           }
+ *         />
+ *       </RevealWidget>
+ * ```
+ * In order to interact with the widget, e.g. for adding and removing models and applying styling,
+ * you need to accommodate the `RevealWidgetController` that is supplied from the Widget with the
+ * `setControllerRef` prop. A simple example that adds a single model and zooms to it
+ * can look like this:
+ * ```
+ * const setControllerRef = useCallback((controllerRef: RevealWidgetController | undefined) => {
+ *   controllerRef?
+ *     .addModel({ type: 'cad', modelId: 12345, revisionId: 23456 })
+ *     .then(model => controllerRef?.cameraController?.focusModel(model));
+ * }, []);
+ * ```
+ */
+export declare function RevealWidget({ viewerOptions, setControllerRef, children, }: PropsWithChildren<RevealWidgetProps>): ReactElement;

package/dist/ui/components/Widget/RevealWidget.js

@@ -0,0 +1,31 @@
+import { ToolUI as e } from "../commandBased/main/ToolUI.js";
+import "../commandBased/index.js";
+import { RevealWidgetContext as t } from "./RevealWidget.context.js";
+import { useContext as n, useEffect as r, useMemo as i } from "react";
+import { jsx as a, jsxs as o } from "react/jsx-runtime";
+//#region libs/shared/reveal-components/src/ui/components/Widget/RevealWidget.tsx
+function s({ viewerOptions: e, setControllerRef: r, children: i }) {
+	let { RevealContext: o } = n(t);
+	if ("inheritFromRevealContext" in e) return /* @__PURE__ */ a(c, {
+		setControllerRef: r,
+		children: i
+	});
+	{
+		let { sdk: t, useCoreDm: n, ...s } = e;
+		return /* @__PURE__ */ a(o, {
+			viewerOptions: s,
+			sdk: t,
+			useCoreDm: n,
+			children: /* @__PURE__ */ a(c, {
+				setControllerRef: r,
+				children: i
+			})
+		});
+	}
+}
+function c({ setControllerRef: s, children: c }) {
+	let { createRevealWidgetController: l, RevealCanvas: u, useRenderTarget: d } = n(t), f = d(), p = i(() => l(f), [f, l]);
+	return r(() => (s?.(p), () => s?.(void 0)), [s, p]), /* @__PURE__ */ o(u, { children: [c, /* @__PURE__ */ a(e, {})] });
+}
+//#endregion
+export { s as RevealWidget };

package/dist/ui/components/Widget/RevealWidgetCameraController.d.ts

@@ -0,0 +1,27 @@
+import { CameraState } from '@cognite/reveal';
+import { RevealDomainObject, RevealRenderTarget } from '../../../domains';
+/**
+ * Controller class for simple camera manipulation in
+ * the RevealWidget
+ */
+export declare class RevealWidgetCameraController {
+    private _renderTarget;
+    constructor(_renderTarget: RevealRenderTarget);
+    /**
+     * Focus all visible models in the scene
+     */
+    focusCameraAll(): void;
+    /**
+     * Focus on a single given 3D model
+     */
+    focusModel(model: RevealDomainObject): void;
+    /**
+     * Returns the state of the camera in the Reveal viewer
+     */
+    getCameraState(): Required<CameraState>;
+    /**
+     * Sets the state of the camera
+     */
+    setCameraState(cameraState: CameraState): void;
+    enterNearby360Image(): Promise<void> | undefined;
+}

package/dist/ui/components/Widget/RevealWidgetCameraController.js

@@ -0,0 +1,27 @@
+import { enterNearby360Image as e } from "../../../utilities/navigation/enterNearby360Image.js";
+import "../../../utilities/navigation/index.js";
+import { CDF_TO_VIEWER_TRANSFORMATION as t } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/ui/components/Widget/RevealWidgetCameraController.ts
+var n = class {
+	_renderTarget;
+	constructor(e) {
+		this._renderTarget = e;
+	}
+	focusCameraAll() {
+		this._renderTarget.fitView();
+	}
+	focusModel(e) {
+		this._renderTarget.viewer.fitCameraToBoundingBox(e.getBoundingBox().applyMatrix4(t));
+	}
+	getCameraState() {
+		return this._renderTarget.viewer.cameraManager.getCameraState();
+	}
+	setCameraState(e) {
+		return this._renderTarget.viewer.cameraManager.setCameraState(e);
+	}
+	enterNearby360Image() {
+		return e(this._renderTarget.viewer);
+	}
+};
+//#endregion
+export { n as RevealWidgetCameraController };