@cognite/reveal-components 1.0.0

package/dist/domains/pointsOfInterest/getPoiIntersectionFromPixel.js

@@ -0,0 +1,12 @@
+import { isPointsOfInterestIntersection as e } from "./types.js";
+import { getClosestDomainObjectIntersection as t } from "../../foundation/domainObjectsHelpers/getClosestDomainObjectIntersection.js";
+import { PointsOfInterestDomainObject as n } from "./PointsOfInterestDomainObject.js";
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/getPoiIntersectionFromPixel.ts
+function r(r, i, a) {
+	let o = i.getDescendantByType(n);
+	if (o === void 0 || o.pointsOfInterest.length === 0 || !o.isVisible(r)) return;
+	let s = t(r, [o], a);
+	if (e(s)) return s;
+}
+//#endregion
+export { r as getPoiIntersectionFromPixel };

package/dist/domains/pointsOfInterest/index.d.ts

@@ -0,0 +1,3 @@
+export { PointsOfInterestDomainObject } from './PointsOfInterestDomainObject';
+export { PointsOfInterestView } from './PointsOfInterestView';
+export { isPointsOfInterestIntersection, type PointOfInterest } from './types';

package/dist/domains/pointsOfInterest/index.js

@@ -0,0 +1,4 @@
+import { isPointsOfInterestIntersection as e } from "./types.js";
+import { PointsOfInterestDomainObject as t } from "./PointsOfInterestDomainObject.js";
+import { PointsOfInterestView as n } from "./PointsOfInterestView.js";
+export { t as PointsOfInterestDomainObject, n as PointsOfInterestView, e as isPointsOfInterestIntersection };

package/dist/domains/pointsOfInterest/models.d.ts

@@ -0,0 +1,27 @@
+import { DmsUniqueIdentifier } from '../../data-providers/FdmSDK';
+import { InstanceReference } from '../../utilities/instanceIds';
+export type PoiVisibility = 'PUBLIC' | 'PRIVATE';
+export type SceneState = Record<string, unknown>;
+export type PointsOfInterestProperties = {
+    name: string;
+    description?: string;
+    ownerId?: string;
+    createdTime?: number;
+    lastUpdatedTime?: number;
+    positionX: number;
+    positionY: number;
+    positionZ: number;
+    scene: DmsUniqueIdentifier;
+    instanceRef?: InstanceReference;
+    sceneState: SceneState;
+    visibility?: PoiVisibility;
+};
+export type CommentProperties = {
+    ownerId: string;
+    content: string;
+    createdTime?: number;
+};
+export type PointsOfInterestInstance<ID> = {
+    id: ID;
+    properties: PointsOfInterestProperties;
+};

package/dist/domains/pointsOfInterest/poiMarkerTextures.d.ts

@@ -0,0 +1,12 @@
+import { Texture } from 'three';
+export type PoiMarkerTextures = {
+    default: Texture;
+    hover: Texture;
+    selected: Texture;
+};
+export type PoiMarkerTexturesDeps = {
+    loadTexture: (url: string) => Texture;
+};
+export declare const defaultPoiMarkerTexturesDeps: PoiMarkerTexturesDeps;
+export declare function getPoiMarkerTextures(): PoiMarkerTextures;
+export declare function createPoiMarkerTextures(deps?: PoiMarkerTexturesDeps): PoiMarkerTextures;

package/dist/domains/pointsOfInterest/poiMarkerTextures.js

@@ -0,0 +1,25 @@
+import e from "../../assets/poi-markers/poi-default.js";
+import t from "../../assets/poi-markers/poi-hover.js";
+import n from "../../assets/poi-markers/poi-selected.js";
+import { SRGBColorSpace as r, TextureLoader as i } from "three";
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/poiMarkerTextures.ts
+var a = { loadTexture: u }, o, s = new i();
+function c() {
+	return o === void 0 && (o = l()), o;
+}
+function l(r = a) {
+	let i = r.loadTexture(e);
+	return i.flipY = !1, {
+		default: i,
+		hover: r.loadTexture(t),
+		selected: r.loadTexture(n)
+	};
+}
+function u(e) {
+	let t = s.load(e, () => {
+		t.needsUpdate = !0;
+	});
+	return t.colorSpace = r, t;
+}
+//#endregion
+export { l as createPoiMarkerTextures, a as defaultPoiMarkerTexturesDeps, c as getPoiMarkerTextures };

package/dist/domains/pointsOfInterest/selectPoiFromPointer.d.ts

@@ -0,0 +1,9 @@
+import { DomainObject } from '../../foundation/domainObjects/DomainObject';
+import { RevealRenderTarget } from '../../foundation/renderTarget/RevealRenderTarget';
+import { GetPoiIntersection } from './types';
+/**
+ * Selects a POI under the pointer using the same POI-only intersection as hover
+ * and zooms the camera to it.
+ * Returns true when a POI was selected so callers can skip other click handling.
+ */
+export declare function selectPoiFromPointer<PoiIdType>(renderTarget: RevealRenderTarget, root: DomainObject, event: PointerEvent, getPoiIntersection: GetPoiIntersection): boolean;

package/dist/domains/pointsOfInterest/selectPoiFromPointer.js

@@ -0,0 +1,11 @@
+import { isPointsOfInterestIntersection as e } from "./types.js";
+import { PointsOfInterestDomainObject as t } from "./PointsOfInterestDomainObject.js";
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/selectPoiFromPointer.ts
+function n(n, r, i, a) {
+	let o = r.getDescendantByType(t);
+	if (o === void 0 || o.pointsOfInterest.length === 0 || !o.isVisible(n)) return !1;
+	let s = a(i);
+	return !e(s) || s.domainObject !== o ? !1 : (s.domainObject.focusOn(s.userData), !0);
+}
+//#endregion
+export { n as selectPoiFromPointer };

package/dist/domains/pointsOfInterest/types.d.ts

@@ -0,0 +1,30 @@
+import { Vector3 } from 'three';
+import { AnyIntersection, ICustomObject } from '@cognite/reveal';
+import { DmsUniqueIdentifier } from '../../data-providers/FdmSDK';
+import { DomainObjectIntersection } from '../../foundation/domainObjectsHelpers/DomainObjectIntersection';
+import { InstanceReference } from '../../utilities/instanceIds';
+import { PointsOfInterestProperties } from './models';
+import { PointsOfInterestDomainObject } from './PointsOfInterestDomainObject';
+export declare enum PointsOfInterestStatus {
+    Default = 0,
+    PendingDeletion = 1,
+    PendingCreation = 2,
+    PendingEditing = 3
+}
+export type PointOfInterest<IdType> = {
+    properties: PointsOfInterestProperties;
+    id: IdType;
+    status: PointsOfInterestStatus;
+};
+export declare function getPointOfInterestKey<PoiIdType>(poi: PointOfInterest<PoiIdType>): string;
+export declare function createPointsOfInterestPropertiesFromPointAndTitle(point: Vector3, scene: DmsUniqueIdentifier, name: string, description: string, associatedInstance: InstanceReference | undefined): PointsOfInterestProperties;
+declare const poiMarker: unique symbol;
+export type PointsOfInterestIntersection<PoiIdType> = Omit<DomainObjectIntersection, 'userData' | 'domainObject'> & {
+    marker: typeof poiMarker;
+    domainObject: PointsOfInterestDomainObject<PoiIdType>;
+    userData: PointOfInterest<PoiIdType>;
+};
+export type GetPoiIntersection = (pointerEvent: PointerEvent) => DomainObjectIntersection | undefined;
+export declare function createPointsOfInterestIntersection<PoiIdType>(point: Vector3, distanceToCamera: number, customObject: ICustomObject, domainObject: PointsOfInterestDomainObject<PoiIdType>, overlay: PointOfInterest<PoiIdType>): PointsOfInterestIntersection<PoiIdType>;
+export declare function isPointsOfInterestIntersection<PoiIdType>(objectIntersection: AnyIntersection | undefined): objectIntersection is PointsOfInterestIntersection<PoiIdType>;
+export {};

package/dist/domains/pointsOfInterest/types.js

@@ -0,0 +1,39 @@
+import { convertFromViewerCoordinates as e } from "../../foundation/renderTarget/convertCoordinates.js";
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/types.ts
+var t = /* @__PURE__ */ function(e) {
+	return e[e.Default = 0] = "Default", e[e.PendingDeletion = 1] = "PendingDeletion", e[e.PendingCreation = 2] = "PendingCreation", e[e.PendingEditing = 3] = "PendingEditing", e;
+}({});
+function n(e) {
+	return JSON.stringify(e.id);
+}
+function r(t, n, r, i, a) {
+	let o = e(t);
+	return {
+		positionX: o.x,
+		positionY: o.y,
+		positionZ: o.z,
+		scene: n,
+		sceneState: {},
+		name: r,
+		description: i,
+		instanceRef: a
+	};
+}
+var i = Symbol("poiMarker");
+function a(e, t, n, r, a) {
+	return {
+		type: "customObject",
+		marker: i,
+		point: e,
+		distanceToCamera: t,
+		customObject: n,
+		domainObject: r,
+		userData: a,
+		onClick: () => r.focusOn(a)
+	};
+}
+function o(e) {
+	return e !== void 0 && "marker" in e && e.marker === i;
+}
+//#endregion
+export { t as PointsOfInterestStatus, a as createPointsOfInterestIntersection, r as createPointsOfInterestPropertiesFromPointAndTitle, n as getPointOfInterestKey, o as isPointsOfInterestIntersection };

package/dist/domains/primitives/box/BoxCreator.d.ts

@@ -0,0 +1,24 @@
+import { Ray, Vector3 } from 'three';
+import { DomainObject } from '../../../foundation/domainObjects/DomainObject';
+import { BaseCreator } from '../../../foundation/domainObjectsHelpers/BaseCreator';
+import { BoxDomainObject } from './BoxDomainObject';
+/**
+ * Helper class for generate a BoxDomainObject by clicking around
+ */
+export declare class BoxCreator extends BaseCreator {
+    private readonly _domainObject;
+    constructor(domainObject: BoxDomainObject);
+    get domainObject(): DomainObject;
+    get minimumPointCount(): number;
+    get maximumPointCount(): number;
+    protected addPointCore(ray: Ray, point: Vector3 | undefined, isPending: boolean): boolean;
+    private recalculatePoint;
+    /**
+     * Create the box by adding points. The first point will make a box with a center and a tiny size.
+     * The second point will give the zRotation and the size.x and center.x
+     * The third will give the size.y and center.y
+     * The third will give the size.z and center.z
+     */
+    private rebuild;
+    private getCenterAndSizeFromBoundingBox;
+}

package/dist/domains/primitives/box/BoxCreator.js

@@ -0,0 +1,72 @@
+import { Changes as e } from "../../../foundation/domainObjectsHelpers/Changes.js";
+import { FocusType as t } from "../../../foundation/domainObjectsHelpers/FocusType.js";
+import { forceBetween0AndTwoPi as n } from "../../../foundation/utilities/extensions/mathUtils.js";
+import { PrimitiveType as r } from "../../../foundation/utilities/primitives/PrimitiveType.js";
+import { getClosestPointOnLine as i } from "../../../foundation/utilities/extensions/rayUtils.js";
+import { horizontalAngle as a, verticalDistanceTo as o } from "../../../foundation/utilities/extensions/vectorUtils.js";
+import { Range3 as s } from "../../../foundation/utilities/geometry/Range3.js";
+import { BaseCreator as c } from "../../../foundation/domainObjectsHelpers/BaseCreator.js";
+import { Matrix4 as l, Plane as u, Vector3 as d } from "three";
+//#region libs/shared/reveal-components/src/domains/primitives/box/BoxCreator.ts
+var f = new d(0, 0, 1), p = class extends c {
+	_domainObject;
+	constructor(e) {
+		super(), this._domainObject = e, this._domainObject.focusType = t.Pending;
+	}
+	get domainObject() {
+		return this._domainObject;
+	}
+	get minimumPointCount() {
+		return this.maximumPointCount;
+	}
+	get maximumPointCount() {
+		switch (this._domainObject.primitiveType) {
+			case r.VerticalArea: return 2;
+			case r.HorizontalArea: return 3;
+			case r.Box: return 4;
+			default: throw Error("Unknown primitiveType");
+		}
+	}
+	addPointCore(n, r, i) {
+		let a = this._domainObject;
+		return r = this.recalculatePoint(r, n, a.primitiveType), r !== void 0 && (this.addRawPoint(r, i), this.rebuild(), a.notify(e.geometry), this.isFinished && a.setFocus(t.Focus), !0);
+	}
+	recalculatePoint(e, t, n) {
+		if (n === r.VerticalArea) return e;
+		if (this.notPendingPointCount === 1 || this.notPendingPointCount === 2) {
+			let e = new u().setFromNormalAndCoplanarPoint(f, this.firstPoint);
+			return t.intersectPlane(e, new d()) ?? void 0;
+		}
+		return this.notPendingPointCount === 3 && n === r.Box ? i(t, f, this.points[2], e) : e;
+	}
+	rebuild() {
+		if (this.pointCount === 0) throw Error("Cannot create a box without points");
+		let e = this._domainObject, { box: t } = e;
+		if (this.pointCount === 1) {
+			t.forceMinSize(), t.center.copy(this.firstPoint), e.primitiveType !== r.VerticalArea && (t.center.z += t.size.z / 2);
+			return;
+		}
+		if (this.pointCount === 2) {
+			let e = new d().subVectors(this.firstPoint, this.lastPoint);
+			t.rotation.z = n(a(e));
+		}
+		let i = e.primitiveType;
+		if (this.pointCount <= 3) {
+			let e = new d(), n = new d();
+			this.getCenterAndSizeFromBoundingBox(t.rotation.z, e, n), t.center.x = e.x, t.size.x = n.x, i === r.VerticalArea ? (t.center.z = e.z, t.center.y = e.y, t.size.z = n.z) : (t.center.y = e.y, t.size.y = n.y), t.forceMinSize();
+		} else {
+			let e = this.points[2], n = this.points[3], r = o(e, n), i = (e.z + n.z) / 2;
+			t.size.z = r, t.center.z = i;
+		}
+	}
+	getCenterAndSizeFromBoundingBox(e, t, n) {
+		let r = new l().makeRotationZ(e), i = r.clone().invert(), a = new s();
+		for (let e of this.points) {
+			let t = e.clone();
+			t.applyMatrix4(i), a.add(t);
+		}
+		a.getCenter(t), a.getDelta(n), t.applyMatrix4(r);
+	}
+};
+//#endregion
+export { p as BoxCreator };

package/dist/domains/primitives/box/BoxDomainObject.d.ts

@@ -0,0 +1,30 @@
+import { Box3, Vector3 } from 'three';
+import { CreateDraggerProps } from '../../../foundation/domainObjects/VisualDomainObject';
+import { BaseDragger } from '../../../foundation/domainObjectsHelpers/BaseDragger';
+import { PanelInfo } from '../../../foundation/domainObjectsHelpers/PanelInfo';
+import { RenderStyle } from '../../../foundation/renderStyles/RenderStyle';
+import { RevealRenderTarget } from '../../../foundation/renderTarget/RevealRenderTarget';
+import { Box } from '../../../foundation/utilities/primitives/Box';
+import { PrimitiveType } from '../../../foundation/utilities/primitives/PrimitiveType';
+import { TranslationInput } from '../../../foundation/utilities/translation/TranslateInput';
+import { SolidDomainObject } from '../common/SolidDomainObject';
+export declare abstract class BoxDomainObject extends SolidDomainObject {
+    readonly box: Box;
+    private readonly _primitiveType;
+    protected constructor(primitiveType?: PrimitiveType);
+    get typeName(): TranslationInput;
+    createRenderStyle(): RenderStyle | undefined;
+    createDragger(props: CreateDraggerProps): BaseDragger | undefined;
+    get hasPanelInfo(): boolean;
+    getPanelInfo(): PanelInfo | undefined;
+    copyFrom(domainObject: BoxDomainObject, what?: symbol): void;
+    getEditToolCursor(renderTarget: RevealRenderTarget, point?: Vector3): string | undefined;
+    get primitiveType(): PrimitiveType;
+    clear(): void;
+    canMoveCorners(): boolean;
+    canRotateComponent(_component: number): boolean;
+    get area(): number;
+    expandBoundingBox(boundingBox: Box3): void;
+    private setSizeComponent;
+    private setZRotationInDegrees;
+}

package/dist/domains/primitives/box/BoxDomainObject.js

@@ -0,0 +1,114 @@
+import { Changes as e } from "../../../foundation/domainObjectsHelpers/Changes.js";
+import { FocusType as t } from "../../../foundation/domainObjectsHelpers/FocusType.js";
+import { Quantity as n } from "../../../foundation/domainObjectsHelpers/Quantity.js";
+import { PrimitiveType as r, verifyPrimitiveType as i } from "../../../foundation/utilities/primitives/PrimitiveType.js";
+import { SolidDomainObject as a } from "../common/SolidDomainObject.js";
+import { Box as o } from "../../../foundation/utilities/primitives/Box.js";
+import { PanelInfo as s } from "../../../foundation/domainObjectsHelpers/PanelInfo.js";
+import { SolidPrimitiveRenderStyle as c } from "../common/SolidPrimitiveRenderStyle.js";
+import { BoxDragger as l } from "./BoxDragger.js";
+//#region libs/shared/reveal-components/src/domains/primitives/box/BoxDomainObject.ts
+var u = class extends a {
+	box = new o();
+	_primitiveType;
+	constructor(e = r.Box) {
+		super(), i(d, e), this._primitiveType = e;
+	}
+	get typeName() {
+		switch (this.primitiveType) {
+			case r.HorizontalArea: return { key: "HORIZONTAL_AREA" };
+			case r.VerticalArea: return { key: "VERTICAL_AREA" };
+			case r.Box: return { key: "VOLUME" };
+			case r.Point: return { key: "POINT" };
+			default: throw Error("Unknown PrimitiveType");
+		}
+	}
+	createRenderStyle() {
+		return new c();
+	}
+	createDragger(e) {
+		if (e.intersection.userData !== void 0) return new l(e, this);
+	}
+	get hasPanelInfo() {
+		return !0;
+	}
+	getPanelInfo() {
+		let e = new s(), i = this.focusType !== t.Pending, { primitiveType: a } = this, { box: c } = this, { size: l } = c, u = o.isValidSize(l.x), d = o.isValidSize(l.y), p = o.isValidSize(l.z);
+		return (i || u) && m({ key: "LENGTH" }, l.x, n.Length, (e) => {
+			this.setSizeComponent(0, e);
+		}, f), a !== r.VerticalArea && (i || d) && m({ key: "DEPTH" }, l.y, n.Length, (e) => {
+			this.setSizeComponent(1, e);
+		}, f), a !== r.HorizontalArea && (i || p) && m({ key: "HEIGHT" }, l.z, n.Length, (e) => {
+			this.setSizeComponent(2, e);
+		}, f), this.canRotateComponent(2) && i && m({ key: "HORIZONTAL_ANGLE" }, c.zRotationInDegrees, n.Angle, (e) => {
+			this.setZRotationInDegrees(e);
+		}), a !== r.Box && (i || c.hasArea) && m({ key: "AREA" }, this.area, n.Area), a === r.Box && (i || c.hasHorizontalArea) && m({ key: "HORIZONTAL_AREA" }, c.horizontalArea, n.Area), a === r.Box && (i || c.hasVolume) && m({ key: "VOLUME" }, c.volume, n.Volume), e;
+		function m(t, n, r, a, o) {
+			e.add({
+				translationInput: t,
+				value: n,
+				quantity: r,
+				setValue: i ? a : void 0,
+				verifyValue: i ? o : void 0
+			});
+		}
+	}
+	copyFrom(t, n) {
+		super.copyFrom(t, n), (n === void 0 || n === e.geometry) && this.box.copy(t.box);
+	}
+	getEditToolCursor(e, n) {
+		if (this.focusType === t.Body) return "move";
+		if (this.focusType === t.Face) {
+			if (this.focusFace === void 0) return;
+			let t = this.focusFace.getCenter(), n = this.box.getMatrix();
+			return t.applyMatrix4(n), e.getResizeCursor(this.box.center, t);
+		}
+		if (this.focusType === t.Corner) {
+			if (this.focusFace === void 0 || n === void 0) return;
+			let t = this.focusFace.getCenter(), r = this.box.getMatrix();
+			return t.applyMatrix4(r), e.getResizeCursor(n, t);
+		}
+		if (this.focusType === t.Rotation) return "grab";
+	}
+	get primitiveType() {
+		return this._primitiveType;
+	}
+	clear() {
+		super.clear(), this.box.clear();
+	}
+	canMoveCorners() {
+		return !0;
+	}
+	canRotateComponent(e) {
+		return !0;
+	}
+	get area() {
+		let { box: e } = this;
+		switch (this.primitiveType) {
+			case r.Point: return 0;
+			case r.VerticalArea: return e.verticalArea;
+			case r.HorizontalArea: return e.horizontalArea;
+			case r.Box: return e.area;
+			default: throw Error(`Area calculation not implemented for : ${this.primitiveType}`);
+		}
+	}
+	expandBoundingBox(e) {
+		this.box.expandBoundingBox(e);
+	}
+	setSizeComponent(t, n) {
+		n > 0 && n !== this.box.size.getComponent(t) && (this.box.size.setComponent(t, n), this.notify(e.geometry));
+	}
+	setZRotationInDegrees(t) {
+		t !== this.box.zRotationInDegrees && (this.box.zRotationInDegrees = t, this.notify(e.geometry));
+	}
+}, d = [
+	r.Point,
+	r.VerticalArea,
+	r.HorizontalArea,
+	r.Box
+];
+function f(e) {
+	return o.isValidSize(e);
+}
+//#endregion
+export { u as BoxDomainObject };

package/dist/domains/primitives/box/BoxDragger.d.ts

@@ -0,0 +1,33 @@
+import { Ray } from 'three';
+import { VisualDomainObject, CreateDraggerProps } from '../../../foundation/domainObjects/VisualDomainObject';
+import { BaseDragger } from '../../../foundation/domainObjectsHelpers/BaseDragger';
+import { FocusType } from '../../../foundation/domainObjectsHelpers/FocusType';
+import { BoxFace } from '../common/BoxFace';
+import { BoxDomainObject } from './BoxDomainObject';
+/**
+ * The `BoxDragger` class represents a utility for dragging and manipulating a box in a 3D space.
+ * It provides methods for scaling, translating, and rotating the box based on user interactions.
+ * All geometry in this class assume Z-axis is up
+ */
+export declare class BoxDragger extends BaseDragger {
+    private readonly _domainObject;
+    private readonly _face;
+    private readonly _focusType;
+    private readonly _normal;
+    private readonly _planeOfFace;
+    private readonly _centerOfFace;
+    private readonly _cornerSign;
+    private readonly _rotationMatrix;
+    private readonly _originalBox;
+    get face(): BoxFace;
+    get focusType(): FocusType;
+    constructor(props: CreateDraggerProps, domainObject: BoxDomainObject);
+    get domainObject(): VisualDomainObject;
+    onPointerDown(_event: PointerEvent): void;
+    onPointerDrag(event: PointerEvent, ray: Ray): boolean;
+    private applyByFocusType;
+    private translate;
+    private moveFace;
+    private resize;
+    private rotate;
+}

package/dist/domains/primitives/box/BoxDragger.js

@@ -0,0 +1,126 @@
+import { Changes as e } from "../../../foundation/domainObjectsHelpers/Changes.js";
+import { FocusType as t } from "../../../foundation/domainObjectsHelpers/FocusType.js";
+import { forceBetween0AndPi as n, forceBetween0AndTwoPi as r, isAbsEqual as i, round as a } from "../../../foundation/utilities/extensions/mathUtils.js";
+import { PrimitiveType as o } from "../../../foundation/utilities/primitives/PrimitiveType.js";
+import { Box as s } from "../../../foundation/utilities/primitives/Box.js";
+import { BaseDragger as c } from "../../../foundation/domainObjectsHelpers/BaseDragger.js";
+import { getClosestPointOnLine as l } from "../../../foundation/utilities/extensions/rayUtils.js";
+import { getAbsMaxComponent as u } from "../../../foundation/utilities/extensions/vectorUtils.js";
+import { Matrix4 as d, Plane as f, Vector3 as p } from "three";
+import { degToRad as m, radToDeg as h } from "three/src/math/MathUtils.js";
+import { Vector3Pool as g } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/domains/primitives/box/BoxDragger.ts
+var _ = 15, v = class extends c {
+	_domainObject;
+	_face;
+	_focusType;
+	_normal = new p();
+	_planeOfFace = new f();
+	_centerOfFace = new p();
+	_cornerSign = new p();
+	_rotationMatrix;
+	_originalBox = new s();
+	get face() {
+		return this._face;
+	}
+	get focusType() {
+		return this._focusType;
+	}
+	constructor(e, t) {
+		super(e, t);
+		let n = e.intersection.userData;
+		this._domainObject = t, this._face = n.face, this._focusType = n.focusType, this._cornerSign.copy(n.cornerSign), this._face.getNormal(this._normal), this._face.getCenter(this._centerOfFace), this._rotationMatrix = t.box.getRotationMatrix(), this._normal.applyMatrix4(this._rotationMatrix), this._normal.normalize(), this._planeOfFace.setFromNormalAndCoplanarPoint(this._normal, this.point);
+		let r = t.box.getMatrix();
+		this._centerOfFace.applyMatrix4(r), this._originalBox.copy(t.box);
+	}
+	get domainObject() {
+		return this._domainObject;
+	}
+	onPointerDown(e) {
+		this._domainObject.setFocus(this.focusType, this.face);
+	}
+	onPointerDrag(t, n) {
+		return this.transaction === void 0 && (this.transaction = this._domainObject.createTransaction(e.geometry)), this.applyByFocusType(this.focusType, n, t.shiftKey) ? (this.domainObject.notify(e.dragging), !0) : !1;
+	}
+	applyByFocusType(e, n, r) {
+		switch (e) {
+			case t.Face: return this.moveFace(n, r);
+			case t.Corner: return this.resize(n);
+			case t.Body: return this.translate(n, r);
+			case t.Rotation: return this.rotate(n, r);
+			default: return !1;
+		}
+	}
+	translate(e, t) {
+		let n = e.intersectPlane(this._planeOfFace, b());
+		if (n === null) return !1;
+		let r = n.sub(this.point);
+		if (r.length() < 1e-6) return !1;
+		if (t) {
+			let e = this._rotationMatrix.clone().invert();
+			r.applyMatrix4(e);
+			let t = u(r);
+			for (let e = 0; e < 3; e++) e !== t && r.setComponent(e, 0);
+			r.applyMatrix4(this._rotationMatrix);
+		}
+		let i = this._originalBox, { box: a } = this._domainObject;
+		return a.copy(i), a.center.add(r), !0;
+	}
+	moveFace(e, t) {
+		let n = b();
+		l(e, this._normal, this.point, n);
+		let r = this._planeOfFace.distanceToPoint(n);
+		if (Math.abs(r) < 1e-6) return !1;
+		let a = this._originalBox, { box: c } = this._domainObject;
+		c.copy(a);
+		let { size: u, center: d } = c, f = this._face.index, p;
+		if (this._domainObject.primitiveType !== o.Box) p = this._face.sign * r;
+		else {
+			let e = r + u.getComponent(f), n = this.getBestValue(e, t, s.MinSize);
+			if (i(n, a.size.getComponent(f), 1e-6)) return !1;
+			u.setComponent(f, n);
+			let o = u.getComponent(f) - a.size.getComponent(f);
+			p = this._face.sign * o / 2;
+		}
+		let m = b();
+		return m.setComponent(f, p), m.applyMatrix4(this._rotationMatrix), d.add(m), !0;
+	}
+	resize(e) {
+		let t = e.intersectPlane(this._planeOfFace, b());
+		if (t === null) return !1;
+		let n = this._planeOfFace.projectPoint(this.point, b()), r = this._rotationMatrix.clone().invert(), i = t.sub(n);
+		if (i.applyMatrix4(r), i.multiply(this._cornerSign), i.length() < 1e-6) return !1;
+		let a = this._originalBox, { box: o } = this._domainObject;
+		o.copy(a);
+		let { size: s, center: c } = o;
+		if (s.add(i), o.forceMinSize(), s.distanceTo(a.size) < 1e-6) return !1;
+		let l = b().subVectors(s, a.size).divideScalar(2);
+		return l.multiply(this._cornerSign), l.applyMatrix4(this._rotationMatrix), c.add(l), !0;
+	}
+	rotate(e, t) {
+		let i = this._domainObject;
+		if (!i.canRotateComponent(this._face.index)) return !1;
+		let o = e.intersectPlane(this._planeOfFace, b());
+		if (o === null) return !1;
+		let s = b().subVectors(this.point, this._centerOfFace).normalize(), c = b().subVectors(o, this._centerOfFace).normalize(), l = b().crossVectors(c, s).normalize(), u = c.angleTo(s);
+		if (Math.abs(u) < 1e-6) return !1;
+		this._normal.dot(l) > 0 && (u = -u);
+		let f = this._originalBox, { box: p } = i;
+		p.copy(f), t && (u = y(u, this._face.index));
+		let g = this._rotationMatrix.clone(), v = new d().makeRotationAxis(this._normal, u);
+		return g.premultiply(v), p.rotation.setFromRotationMatrix(g), !0;
+		function y(e, t) {
+			let i = f.getRotationAngleByComponent(t), o;
+			return o = t === 2 ? p.hasXYRotation ? r(e + i) : n(e + i) : r(e + i), o = s(o), o - i;
+			function s(e) {
+				let t = h(e);
+				return t = a(t, _), m(t);
+			}
+		}
+	}
+}, y = new g();
+function b(e) {
+	return y.getNext(e);
+}
+//#endregion
+export { v as BoxDragger };

package/dist/domains/primitives/box/BoxView.d.ts

@@ -0,0 +1,45 @@
+import { Mesh, MeshPhongMaterial, LineBasicMaterial, Matrix4, Sprite, PerspectiveCamera } from 'three';
+import { LineMaterial } from 'three/examples/jsm/lines/LineMaterial.js';
+import { CustomObjectIntersectInput, CustomObjectIntersection } from '@cognite/reveal';
+import { DomainObject } from '../../../foundation/domainObjects/DomainObject';
+import { DomainObjectChange } from '../../../foundation/domainObjectsHelpers/DomainObjectChange';
+import { GroupThreeView } from '../../../foundation/views/GroupThreeView';
+import { BoxFace } from '../common/BoxFace';
+import { PrimitiveRenderStyle } from '../common/PrimitiveRenderStyle';
+import { SolidPrimitiveRenderStyle } from '../common/SolidPrimitiveRenderStyle';
+import { BoxDomainObject } from './BoxDomainObject';
+export declare class BoxView extends GroupThreeView<BoxDomainObject> {
+    private readonly _sprites;
+    private readonly _visibleFaces;
+    protected get style(): SolidPrimitiveRenderStyle;
+    update(change: DomainObjectChange): void;
+    beforeRender(camera: PerspectiveCamera): void;
+    get useDepthTest(): boolean;
+    protected addChildren(): void;
+    intersectIfCloser(intersectInput: CustomObjectIntersectInput, closestDistance: number | undefined): undefined | CustomObjectIntersection;
+    private getTextHeight;
+    private getFaceRadius;
+    private getMatrix;
+    private getRotationMatrix;
+    private createSolid;
+    private createLines;
+    private createWireframe;
+    private createRotationLabel;
+    private createPendingLabel;
+    private createRotationRing;
+    private createEdgeCircle;
+    private addLabels;
+    private updateLabels;
+    private addEdgeCircles;
+    private addRotationRing;
+    private getPickedFocusType;
+    private getCornerSign;
+    private getCorner;
+    private isFaceVisible;
+}
+export declare function updateSolidMaterial(material: MeshPhongMaterial, domainObject: DomainObject, style: SolidPrimitiveRenderStyle): void;
+export declare function updateLineSegmentsMaterial(material: LineBasicMaterial, domainObject: DomainObject, style: SolidPrimitiveRenderStyle, depthTest: boolean): void;
+export declare function updateWireframeMaterial(material: LineMaterial, domainObject: DomainObject, style: SolidPrimitiveRenderStyle, depthTest: boolean): void;
+export declare function updateMarkerMaterial(material: MeshPhongMaterial, hasFocus: boolean, depthTest: boolean): void;
+export declare function rotateEdgeCircle(mesh: Mesh, face: BoxFace, rotationMatrix: Matrix4): void;
+export declare function createSprite(text: string, style: PrimitiveRenderStyle, height: number): Sprite;