@cognite/reveal-components 1.0.0

package/dist/foundation/renderTarget/CommandsController.js

@@ -0,0 +1,157 @@
+import { isInstanceOf as e } from "../domainObjectsHelpers/Class.js";
+import { clear as t, remove as n } from "../utilities/extensions/arrayUtils.js";
+import { DeferredFunction as r } from "../utilities/misc/DeferredFunction.js";
+import { signal as i } from "@cognite/signal-utils";
+import { PointerEvents as a, PointerEventsTarget as o, getWheelEventDelta as s } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/foundation/renderTarget/CommandsController.ts
+var c = class extends a {
+	_activeTool = i();
+	_defaultTool;
+	_previousTool;
+	_domElement;
+	_commands = /* @__PURE__ */ new Set();
+	_pointerEventsTarget;
+	_deferredUpdate;
+	_pointerEventListeners = [];
+	constructor(e) {
+		super(), this._domElement = e, this._pointerEventsTarget = new o(this._domElement, this);
+		let t = () => {
+			for (let e of this._commands) e.update();
+		};
+		this._deferredUpdate = new r(t);
+	}
+	get activeTool() {
+		return this._activeTool();
+	}
+	get activeToolSignal() {
+		return this._activeTool;
+	}
+	get defaultTool() {
+		return this._defaultTool;
+	}
+	get isDefaultToolActive() {
+		return this.activeTool === this.defaultTool;
+	}
+	get isEnabled() {
+		return !0;
+	}
+	onHover(e) {
+		this.activeTool?.onHoverByDebounce(e);
+	}
+	async onClick(e) {
+		this._domElement.focus(), this.updateListeners("click", e), await this.activeTool?.onClick(e);
+	}
+	async onDoubleClick(e) {
+		this._domElement.focus(), this.updateListeners("doubleClick", e), await this.activeTool?.onDoubleClick(e);
+	}
+	async onPointerDown(e, t) {
+		this._domElement.focus(), t ? await this.activeTool?.onLeftPointerDown(e) : await this.defaultTool?.onRightPointerDown(e);
+	}
+	async onPointerDrag(e, t) {
+		t ? await this.activeTool?.onLeftPointerDrag(e) : await this.defaultTool?.onRightPointerDrag(e);
+	}
+	async onPointerUp(e, t) {
+		t ? await this.activeTool?.onLeftPointerUp(e) : await this.defaultTool?.onRightPointerUp(e);
+	}
+	getEqual(e) {
+		for (let t of this._commands) if (t.equals(e)) return t;
+	}
+	add(e) {
+		this._commands.add(e);
+	}
+	setPreviousTool() {
+		return this._previousTool !== void 0 && this.setActiveTool(this._previousTool);
+	}
+	setDefaultTool(e) {
+		return e !== void 0 && (this._defaultTool = e, this.activateDefaultTool());
+	}
+	getToolByType(t) {
+		for (let n of this._commands) if (e(n, t)) return n;
+	}
+	getCommandByTypeRecursive(t) {
+		for (let n of this._commands) {
+			if (e(n, t)) return n;
+			for (let r of n.getDescendants()) if (e(r, t)) return r;
+		}
+	}
+	setActiveToolByType(t) {
+		for (let n of this._commands) if (e(n, t)) return this.setActiveTool(n);
+		return !1;
+	}
+	activateDefaultTool() {
+		return this._defaultTool !== void 0 && this.setActiveTool(this._defaultTool);
+	}
+	setActiveTool(e) {
+		if (e === void 0) return !1;
+		let t = this.activeTool;
+		return t !== e && (t !== void 0 && (this._activeTool(void 0), t.onDeactivate(), this._previousTool = t), this._activeTool(e), this._activeTool()?.onActivate(), !0);
+	}
+	deferredUpdate() {
+		this._deferredUpdate.trigger();
+	}
+	dispose() {
+		for (let e of this._commands) e.dispose();
+		this._deferredUpdate.dispose();
+	}
+	onKey(e, t) {
+		if (t) {
+			let t = e.key.toUpperCase(), n = e.ctrlKey || e.metaKey;
+			for (let r of this._commands) if (r.hasShortCutKey(t, n, e.shiftKey, e.altKey)) {
+				r.invoke();
+				return;
+			}
+		}
+		if (t && (e.key === "Delete" || e.key === "Backspace")) this.activeTool?.onDeleteKey();
+		else if (t && e.key === "Escape") {
+			if (this.activeTool?.onEscapeKey()) {
+				e.stopPropagation(), e.preventDefault();
+				return;
+			}
+		} else this.activeTool?.onKey(e, t);
+		t && this.updateListeners("keyDown", e);
+	}
+	addEventListeners() {
+		let e = this._domElement;
+		e.addEventListener("pointermove", this._onPointerMove), e.addEventListener("keydown", this._onKeyDown), e.addEventListener("keyup", this._onKeyUp), e.addEventListener("wheel", this._onWheel), e.addEventListener("focus", this._onFocus), e.addEventListener("blur", this._onBlur), e.addEventListener("contextmenu", this._onContextMenu), this._pointerEventsTarget.addEventListeners();
+	}
+	removeEventListeners() {
+		let e = this._domElement;
+		e.removeEventListener("pointermove", this._onPointerMove), e.removeEventListener("keydown", this._onKeyDown), e.removeEventListener("keyup", this._onKeyUp), e.removeEventListener("wheel", this._onWheel), e.removeEventListener("focus", this._onFocus), e.removeEventListener("blur", this._onBlur), e.removeEventListener("contextmenu", this._onContextMenu), this._pointerEventsTarget.removeEventListeners();
+		for (let e of this._commands) e.removeEventListeners();
+		t(this._pointerEventListeners);
+	}
+	addEventListener(e) {
+		this._pointerEventListeners.push(e);
+	}
+	removeEventListener(e) {
+		n(this._pointerEventListeners, e);
+	}
+	updateListeners(e, t) {
+		let n = this.activeTool;
+		if (n !== void 0) for (let r of this._pointerEventListeners) r(e, t, n);
+	}
+	_onPointerMove = (e) => {
+		e.buttons === 0 && (this.activeTool?.onHover(e), this.updateListeners("hover", e));
+	};
+	_onKeyDown = (e) => {
+		this.onKey(e, !0);
+	};
+	_onContextMenu = (e) => {
+		e.stopPropagation(), e.preventDefault();
+	};
+	_onKeyUp = (e) => {
+		this.onKey(e, !1);
+	};
+	_onWheel = async (e) => {
+		let t = s(e);
+		await this.activeTool?.onWheel(e, t), e.stopPropagation(), e.preventDefault();
+	};
+	_onFocus = (e) => {
+		this.activeTool?.onFocusChanged(!0);
+	};
+	_onBlur = (e) => {
+		this.activeTool?.onFocusChanged(!1);
+	};
+};
+//#endregion
+export { c as CommandsController };

package/dist/foundation/renderTarget/DefaultRevealConfig.d.ts

@@ -0,0 +1,3 @@
+import { BaseRevealConfig } from './BaseRevealConfig';
+export declare class DefaultRevealConfig extends BaseRevealConfig {
+}

package/dist/foundation/renderTarget/DefaultRevealConfig.js

@@ -0,0 +1,5 @@
+import { BaseRevealConfig as e } from "./BaseRevealConfig.js";
+//#region libs/shared/reveal-components/src/foundation/renderTarget/DefaultRevealConfig.ts
+var t = class extends e {};
+//#endregion
+export { t as DefaultRevealConfig };

package/dist/foundation/renderTarget/InstanceStylingController.d.ts

@@ -0,0 +1,10 @@
+import { InstanceStylingGroup } from '../../utilities/modelIds/types';
+export declare class InstanceStylingController {
+    private readonly _eventHandlers;
+    private readonly _stylingMap;
+    setStylingGroup(symbol: symbol, group: InstanceStylingGroup | undefined): void;
+    getStylingGroups(): Iterable<InstanceStylingGroup>;
+    addEventListener(eventHandler: () => void): void;
+    removeEventListener(eventHandler: () => void): boolean;
+    private fireChangeEvent;
+}

package/dist/foundation/renderTarget/InstanceStylingController.js

@@ -0,0 +1,29 @@
+import { remove as e } from "../utilities/extensions/arrayUtils.js";
+//#region libs/shared/reveal-components/src/foundation/renderTarget/InstanceStylingController.ts
+var t = class {
+	_eventHandlers = [];
+	_stylingMap = /* @__PURE__ */ new Map();
+	setStylingGroup(e, t) {
+		if (t === void 0) {
+			this._stylingMap.delete(e), this.fireChangeEvent();
+			return;
+		}
+		this._stylingMap.set(e, t), this.fireChangeEvent();
+	}
+	getStylingGroups() {
+		return this._stylingMap.values();
+	}
+	addEventListener(e) {
+		this._eventHandlers.push(e);
+	}
+	removeEventListener(t) {
+		return e(this._eventHandlers, t);
+	}
+	fireChangeEvent() {
+		this._eventHandlers.forEach((e) => {
+			e();
+		});
+	}
+};
+//#endregion
+export { t as InstanceStylingController };

package/dist/foundation/renderTarget/RenderTarget.d.ts

@@ -0,0 +1,30 @@
+import { Box3, Plane } from 'three';
+import { ICustomObject } from '@cognite/reveal';
+import { DomainObject } from '../domainObjects/DomainObject';
+import { RootDomainObject } from '../domainObjects/RootDomainObject';
+import { DomainObjectChange } from '../domainObjectsHelpers/DomainObjectChange';
+/**
+ * Interface for render targets in the Reveal 3D viewer architecture.
+ *
+ * This interface provides the foundation for managing 3D rendering contexts,
+ * and scene management. It defines the interface that concrete render target implementations must follow.
+ * It is for instance used by the ThreeView to manage the rendering of 3D scenes.
+ */
+export interface RenderTarget {
+    get root(): RootDomainObject;
+    get sceneBoundingBox(): Box3;
+    get clippedVisualSceneBoundingBox(): Box3;
+    get isGlobalClippingActive(): boolean;
+    get isGlobalCropBoxActive(): boolean;
+    addCustomObject(customObject: ICustomObject): void;
+    removeCustomObject(customObject: ICustomObject): void;
+    invalidate(): void;
+    fitView(): void;
+    updateAllCommands(): void;
+    activateDefaultTool(): void;
+    notifyPanel(domainObject: DomainObject, change: DomainObjectChange): void;
+    isGlobalCropBox(domainObject: DomainObject): boolean;
+    getGlobalClippingPlanes(): Plane[];
+    setGlobalClipping(clippingPlanes: Plane[], domainObject?: DomainObject): void;
+    clearGlobalClipping(): void;
+}

package/dist/foundation/renderTarget/RevealRenderTarget.d.ts

@@ -0,0 +1,109 @@
+import { Vector3, PerspectiveCamera, Box3, Plane } from 'three';
+import { CameraManager, Cognite3DViewer, IFlexibleCameraManager, DataSourceType, ICustomObject } from '@cognite/reveal';
+import { CogniteClient } from '@cognite/sdk';
+import { DmsUniqueIdentifier } from '../../data-providers/FdmSDK';
+import { RevealSettingsController } from '../../domains/reveal/RevealSettingsController';
+import { LoadMetricsRecorder } from '../../utilities/loadMetricsParameters';
+import { BaseCommand } from '../commands/BaseCommand';
+import { BaseTool } from '../commands/BaseTool';
+import { DomainObject } from '../domainObjects/DomainObject';
+import { RootDomainObject } from '../domainObjects/RootDomainObject';
+import { Class } from '../domainObjectsHelpers/Class';
+import { DomainObjectChange } from '../domainObjectsHelpers/DomainObjectChange';
+import { DomainObjectPanelUpdater } from '../reactUpdaters/DomainObjectPanelUpdater';
+import { TrackingDelegate } from '../utilities/types';
+import { BaseRevealConfig } from './BaseRevealConfig';
+import { CdfCaches } from './CdfCaches';
+import { CommandsController } from './CommandsController';
+import { InstanceStylingController } from './InstanceStylingController';
+import { RenderTarget } from './RenderTarget';
+export type RevealRenderTargetOptions = {
+    coreDmOnly?: boolean;
+    enableLegacy3dFdm?: boolean;
+    enableDirectionalMarker?: boolean;
+    trackingDelegate?: TrackingDelegate;
+    featureDataLoadPerformanceMetrics?: LoadMetricsRecorder;
+};
+export declare class RevealRenderTarget implements RenderTarget {
+    private readonly _viewer;
+    private readonly _commandsController;
+    private readonly _rootDomainObject;
+    private readonly _cdfCaches;
+    private readonly _instanceStylingController;
+    private readonly _revealSettingsController;
+    private readonly _panelUpdater;
+    private _ambientLight;
+    private _directionalLight;
+    private _clippedBoundingBox;
+    private _cropBoxUniqueId;
+    private _axisGizmoTool;
+    private _config;
+    ghostMode: boolean;
+    readonly enableDirectionalMarker: boolean;
+    constructor(viewer: Cognite3DViewer<DataSourceType>, sdk: CogniteClient, options?: RevealRenderTargetOptions);
+    get viewer(): Cognite3DViewer<DataSourceType>;
+    get isInside360Image(): boolean;
+    get active360ImageId(): string | DmsUniqueIdentifier | undefined;
+    get config(): BaseRevealConfig | undefined;
+    get root(): RootDomainObject;
+    get domElement(): HTMLElement;
+    get commandsController(): CommandsController;
+    get cdfCaches(): CdfCaches;
+    get instanceStylingController(): InstanceStylingController;
+    get revealSettingsController(): RevealSettingsController;
+    get panelUpdater(): DomainObjectPanelUpdater;
+    get cursor(): string;
+    set cursor(value: string | undefined);
+    get cameraManager(): CameraManager;
+    get flexibleCameraManager(): IFlexibleCameraManager;
+    get camera(): PerspectiveCamera;
+    get clippedVisualSceneBoundingBox(): Box3;
+    get sceneBoundingBox(): Box3;
+    get visualSceneBoundingBox(): Box3;
+    addCustomObject(customObject: ICustomObject): void;
+    removeCustomObject(customObject: ICustomObject): void;
+    /**
+     * Gets or registers a default command instance.
+     *
+     * If the command doesn't have its own data and an equal command already exists in the controller,
+     * returns the existing command to avoid duplicates. Otherwise, adds the new command to
+     * the controller. It also ensures the render target is attached if it's a RenderTargetCommand.
+     *
+     * @template T - A type extending BaseCommand
+     * @param newCommand - The command to get or register
+     * @returns The existing equivalent command if found, or the new command after registration
+     */
+    getDefaultCommand<T extends BaseCommand>(newCommand: T): T;
+    updateAllCommands(): void;
+    activateDefaultTool(): void;
+    setDefaultTool(tool: BaseTool): boolean;
+    setActiveToolByType<T extends BaseTool>(classType: Class<T>): boolean;
+    notifyPanel(domainObject: DomainObject, change: DomainObjectChange): void;
+    setConfig(config: BaseRevealConfig): void;
+    onStartup(): void;
+    dispose(): void;
+    invalidate(): void;
+    private initializeLights;
+    private readonly cameraChangeHandler;
+    fitView(): boolean;
+    getGlobalClippingPlanes(): Plane[];
+    get isGlobalClippingActive(): boolean;
+    get isGlobalCropBoxActive(): boolean;
+    isGlobalCropBox(domainObject: DomainObject): boolean;
+    setGlobalClipping(clippingPlanes: Plane[], domainObject?: DomainObject): void;
+    clearGlobalClipping(): void;
+    setDefaultCursor(): void;
+    setNavigateCursor(): void;
+    setCrosshairCursor(): void;
+    /**
+     * Sets the resize cursor based on two points in 3D space to the resize
+     * // cursor has a correct direction.
+     * @param point1 - The first point in CDF space.
+     * @param point2 - The second point in CDF space.
+     */
+    getResizeCursor(point1: Vector3, point2: Vector3): string | undefined;
+    /**
+     * Cleans up all domain objects that satisfy `cleanupPredicate`, or all if none is provided
+     */
+    cleanup(cleanupPredicate?: (obj: DomainObject) => boolean): void;
+}

package/dist/foundation/renderTarget/RevealRenderTarget.js

@@ -0,0 +1,220 @@
+import { RenderTargetCommand as e } from "../commands/RenderTargetCommand.js";
+import { Changes as t } from "../domainObjectsHelpers/Changes.js";
+import { getOctant as n } from "../utilities/extensions/vectorUtils.js";
+import { Range3 as r } from "../utilities/geometry/Range3.js";
+import { VIEWER_TO_CDF_TRANSFORMATION as i, convertToViewerCoordinates as a } from "./convertCoordinates.js";
+import { RevealSettingsController as o } from "../../domains/reveal/RevealSettingsController.js";
+import { RootDomainObject as s } from "../domainObjects/RootDomainObject.js";
+import { DomainObjectPanelUpdater as c } from "../reactUpdaters/DomainObjectPanelUpdater.js";
+import { getBoundingBoxFromPlanes as l } from "../utilities/geometry/getBoundingBoxFromPlanes.js";
+import { getResizeCursor as u } from "../utilities/geometry/getResizeCursor.js";
+import { CdfCaches as d } from "./CdfCaches.js";
+import { CommandsController as f } from "./CommandsController.js";
+import { DefaultRevealConfig as p } from "./DefaultRevealConfig.js";
+import { InstanceStylingController as m } from "./InstanceStylingController.js";
+import { AmbientLight as h, DirectionalLight as g, Vector3 as _ } from "three";
+import { CDF_TO_VIEWER_TRANSFORMATION as v, CustomObject as y, Image360Action as b, isFlexibleCameraManager as x } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/foundation/renderTarget/RevealRenderTarget.ts
+var S = "DirectionalLight", C = class {
+	_viewer;
+	_commandsController;
+	_rootDomainObject;
+	_cdfCaches;
+	_instanceStylingController;
+	_revealSettingsController;
+	_panelUpdater;
+	_ambientLight;
+	_directionalLight;
+	_clippedBoundingBox;
+	_cropBoxUniqueId = void 0;
+	_axisGizmoTool;
+	_config = void 0;
+	ghostMode = !1;
+	enableDirectionalMarker;
+	constructor(e, t, n) {
+		this._viewer = e, this.enableDirectionalMarker = n?.enableDirectionalMarker ?? !1;
+		let r = n?.coreDmOnly ?? !1, i = n?.coreDmOnly ?? !0;
+		this._cdfCaches = new d(t, e, {
+			coreDmOnly: r,
+			enableLegacy3dFdm: i,
+			trackingDelegate: n?.trackingDelegate,
+			featureDataLoadPerformanceMetrics: n?.featureDataLoadPerformanceMetrics
+		}), this._commandsController = new f(this.domElement), this._commandsController.addEventListeners(), this._instanceStylingController = new m(), this._panelUpdater = new c(), this._rootDomainObject = new s(this, t), this._rootDomainObject.isExpanded = !0, this._revealSettingsController = new o(e, this._rootDomainObject), this.initializeLights(), this._viewer.on("cameraChange", this.cameraChangeHandler), this.setConfig(new p());
+	}
+	get viewer() {
+		return this._viewer;
+	}
+	get isInside360Image() {
+		return this._viewer.canDoImage360Action(b.Exit);
+	}
+	get active360ImageId() {
+		return this._viewer.getActive360ImageInfo()?.image360.id;
+	}
+	get config() {
+		return this._config;
+	}
+	get root() {
+		return this._rootDomainObject;
+	}
+	get domElement() {
+		return this._viewer.domElement;
+	}
+	get commandsController() {
+		return this._commandsController;
+	}
+	get cdfCaches() {
+		return this._cdfCaches;
+	}
+	get instanceStylingController() {
+		return this._instanceStylingController;
+	}
+	get revealSettingsController() {
+		return this._revealSettingsController;
+	}
+	get panelUpdater() {
+		return this._panelUpdater;
+	}
+	get cursor() {
+		return this.domElement.style.cursor;
+	}
+	set cursor(e) {
+		this.domElement.style.cursor = e ?? "default";
+	}
+	get cameraManager() {
+		return this.viewer.cameraManager;
+	}
+	get flexibleCameraManager() {
+		let e = this.cameraManager;
+		if (!x(e)) throw Error("Camera manager is not flexible");
+		return e;
+	}
+	get camera() {
+		return this.cameraManager.getCamera();
+	}
+	get clippedVisualSceneBoundingBox() {
+		if (this._clippedBoundingBox === void 0) return this.visualSceneBoundingBox;
+		let e = this.visualSceneBoundingBox.clone();
+		return e.intersect(this._clippedBoundingBox), e;
+	}
+	get sceneBoundingBox() {
+		return this.viewer.getSceneBoundingBox();
+	}
+	get visualSceneBoundingBox() {
+		return this.viewer.getVisualSceneBoundingBox();
+	}
+	addCustomObject(e) {
+		this.viewer.addCustomObject(e);
+	}
+	removeCustomObject(e) {
+		this.viewer.removeCustomObject(e);
+	}
+	getDefaultCommand(t) {
+		if (!t.hasData) {
+			let e = this.commandsController.getEqual(t);
+			if (e !== void 0) return e;
+			this.commandsController.add(t);
+		}
+		return t instanceof e && t.attach(this), t;
+	}
+	updateAllCommands() {
+		this._commandsController.deferredUpdate();
+	}
+	activateDefaultTool() {
+		this._commandsController.activateDefaultTool();
+	}
+	setDefaultTool(e) {
+		let t = this.commandsController.defaultTool;
+		if (t !== void 0 && e.equals(t)) return !1;
+		let n = this.commandsController.getEqual(e);
+		return n === void 0 ? (e.attach(this), this.commandsController.add(e), this.commandsController.setDefaultTool(e)) : this.commandsController.setDefaultTool(n);
+	}
+	setActiveToolByType(e) {
+		return this.commandsController.setActiveToolByType(e);
+	}
+	notifyPanel(e, t) {
+		this._panelUpdater.notify(e, t);
+	}
+	setConfig(e) {
+		this._config = e, this.setDefaultTool(e.createDefaultTool());
+		let t = e.createAxisGizmoTool();
+		t !== void 0 && (t.connect(this._viewer), this._axisGizmoTool = t);
+	}
+	onStartup() {
+		this._config?.onStartup(this), this.updateAllCommands();
+	}
+	dispose() {
+		this._viewer.dispose(), this._ambientLight !== void 0 && this._viewer.removeObject3D(this._ambientLight), this._directionalLight !== void 0 && this._viewer.removeObject3D(this._directionalLight), this.commandsController.removeEventListeners(), this.commandsController.dispose(), this._axisGizmoTool?.dispose(), this._revealSettingsController.dispose();
+	}
+	invalidate() {
+		this._viewer.requestRedraw();
+	}
+	initializeLights() {
+		this._ambientLight = new h(16777215, .25), this._directionalLight = new g(16777215, 2), this._directionalLight.name = S, this._directionalLight.position.set(0, 1, 0);
+		let e = new y(this._ambientLight), t = new y(this._directionalLight);
+		e.isPartOfBoundingBox = !1, t.isPartOfBoundingBox = !1, this.viewer.addCustomObject(e), this.viewer.addCustomObject(t);
+	}
+	cameraChangeHandler = (e, t) => {
+		let n = this._directionalLight;
+		if (n === void 0) return;
+		let r = this.camera, i = new _();
+		r.getWorldDirection(i), i.negate(), n.position.copy(i);
+	};
+	fitView() {
+		let e = this.viewer;
+		try {
+			e.exit360Image();
+		} catch {}
+		return e.fitCameraToBoundingBox(this.clippedVisualSceneBoundingBox), !0;
+	}
+	getGlobalClippingPlanes() {
+		return this.viewer.getGlobalClippingPlanes === void 0 ? [] : this.viewer.getGlobalClippingPlanes();
+	}
+	get isGlobalClippingActive() {
+		return this.viewer.getGlobalClippingPlanes !== void 0 && this.getGlobalClippingPlanes().length > 0;
+	}
+	get isGlobalCropBoxActive() {
+		return this.isGlobalClippingActive && this._cropBoxUniqueId !== void 0;
+	}
+	isGlobalCropBox(e) {
+		return this._cropBoxUniqueId !== void 0 && e.uniqueId === this._cropBoxUniqueId;
+	}
+	setGlobalClipping(e, n) {
+		if (e.length === 0) {
+			this.clearGlobalClipping();
+			return;
+		}
+		let a = this.sceneBoundingBox.clone();
+		a.applyMatrix4(i);
+		let o = new r();
+		o.copy(a);
+		let s = l(e, o).getBox();
+		for (let t of e) t.applyMatrix4(v);
+		s.applyMatrix4(v), this.viewer.setGlobalClippingPlanes(e), this._clippedBoundingBox = s, this._cropBoxUniqueId = n?.uniqueId, this.root.notifyDescendants(t.clipping);
+	}
+	clearGlobalClipping() {
+		this.viewer.setGlobalClippingPlanes([]), this._clippedBoundingBox = void 0, this._cropBoxUniqueId = void 0, this.root.notifyDescendants(t.clipping);
+	}
+	setDefaultCursor() {
+		this.cursor = "default";
+	}
+	setNavigateCursor() {
+		this.cursor = "pointer";
+	}
+	setCrosshairCursor() {
+		this.cursor = "crosshair";
+	}
+	getResizeCursor(e, t) {
+		e = a(e), t = a(t);
+		let r = this.viewer.worldToScreen(e, !1);
+		if (r === null) return;
+		let i = this.viewer.worldToScreen(t, !1);
+		if (i === null) return;
+		let o = i?.sub(r).normalize();
+		return o.y = -o.y, u(n(o));
+	}
+	cleanup(e) {
+		this.activateDefaultTool(), this.root.cleanup(e);
+	}
+};
+//#endregion
+export { C as RevealRenderTarget };

package/dist/foundation/renderTarget/UnitSystem.d.ts

@@ -0,0 +1,27 @@
+import { Signal } from '@cognite/signal-utils';
+import { Quantity } from '../domainObjectsHelpers/Quantity';
+export declare enum LengthUnit {
+    Meter = "Meter",
+    Feet = "Feet",
+    Inch = "Inch"
+}
+/**
+ * Represents a unit system that handles conversions and formatting of values.
+ * This is a very basic unit system, but could be extended in the future to cover all use cases.
+ */
+export declare class UnitSystem {
+    readonly lengthUnit: Signal<LengthUnit>;
+    readonly _language: string;
+    constructor(language?: string);
+    convertToUnit(value: number, quantity: Quantity): number;
+    convertFromUnit(value: number, quantity: Quantity): number;
+    toString(value: number, quantity: Quantity, useGrouping?: boolean): string;
+    toStringWithUnit(value: number, quantity: Quantity): string;
+    getUnit(quantity: Quantity): string;
+    private getFractionDigits;
+    private getConversionFactorForLengthUnit;
+    private getTextForLengthUnit;
+    private getFractionDigitsForLengthUnits;
+    static getFullTextForLengthUnit(lengthUnit: LengthUnit): string;
+}
+export declare const UNDEFINED_UNIT_SYSTEM: UnitSystem;

package/dist/foundation/renderTarget/UnitSystem.js

@@ -0,0 +1,86 @@
+import { Quantity as e } from "../domainObjectsHelpers/Quantity.js";
+import { round as t } from "../utilities/extensions/mathUtils.js";
+import { isEmpty as n } from "lodash-es";
+import { signal as r } from "@cognite/signal-utils";
+//#region libs/shared/reveal-components/src/foundation/renderTarget/UnitSystem.ts
+var i = 1 / .3048, a = 12 * i, o = /* @__PURE__ */ function(e) {
+	return e.Meter = "Meter", e.Feet = "Feet", e.Inch = "Inch", e;
+}({}), s = class {
+	lengthUnit = r("Meter");
+	_language;
+	constructor(e = "default") {
+		this._language = e;
+	}
+	convertToUnit(e, t) {
+		return c(e, this.getConversionFactorForLengthUnit(), t);
+	}
+	convertFromUnit(e, t) {
+		return c(e, 1 / this.getConversionFactorForLengthUnit(), t);
+	}
+	toString(e, n, r = !0) {
+		let i = this.getFractionDigits(n), a = this.convertToUnit(e, n);
+		return this.lengthUnit() === "Inch" && (a = t(a, .25)), a.toLocaleString(this._language, {
+			useGrouping: r,
+			maximumFractionDigits: i,
+			minimumFractionDigits: i
+		});
+	}
+	toStringWithUnit(e, t) {
+		let r = this.toString(e, t), i = this.getUnit(t);
+		return n(i) ? r : `${r} ${i}`;
+	}
+	getUnit(t) {
+		switch (t) {
+			case e.Unitless: return "";
+			case e.Length: return this.getTextForLengthUnit();
+			case e.Area: return this.getTextForLengthUnit() + "²";
+			case e.Volume: return this.getTextForLengthUnit() + "³";
+			case e.Angle: return "°";
+		}
+	}
+	getFractionDigits(t) {
+		switch (t) {
+			case e.Angle: return 1;
+			case e.Length:
+			case e.Area:
+			case e.Volume: return this.getFractionDigitsForLengthUnits();
+			default: return 2;
+		}
+	}
+	getConversionFactorForLengthUnit() {
+		switch (this.lengthUnit()) {
+			case "Feet": return i;
+			case "Inch": return a;
+			default: return 1;
+		}
+	}
+	getTextForLengthUnit() {
+		switch (this.lengthUnit()) {
+			case "Feet": return "ft";
+			case "Inch": return "in";
+			default: return "m";
+		}
+	}
+	getFractionDigitsForLengthUnits() {
+		return 2;
+	}
+	static getFullTextForLengthUnit(e) {
+		switch (e) {
+			case "Feet": return "Feet (ft)";
+			case "Inch": return "Inches (in)";
+			default: return "Meters (m)";
+		}
+	}
+};
+function c(t, n, r) {
+	if (n === 1) return t;
+	switch (r) {
+		case e.Length: return t * n;
+		case e.Area: return t * n * n;
+		case e.Volume: return t * n * n * n;
+		default: return t;
+	}
+}
+var l = new s();
+//#endregion
+export { o as LengthUnit, l as UNDEFINED_UNIT_SYSTEM, s as UnitSystem };