@cognite/reveal-components 1.0.0

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

@@ -0,0 +1,307 @@
+import { clear as e } from "../../../foundation/utilities/extensions/arrayUtils.js";
+import { Changes as t } from "../../../foundation/domainObjectsHelpers/Changes.js";
+import { FocusType as n } from "../../../foundation/domainObjectsHelpers/FocusType.js";
+import { Quantity as r } from "../../../foundation/domainObjectsHelpers/Quantity.js";
+import { PrimitiveType as i } from "../../../foundation/utilities/primitives/PrimitiveType.js";
+import { BoxFace as a } from "../common/BoxFace.js";
+import { BoxUtils as o } from "../../../foundation/utilities/primitives/BoxUtils.js";
+import { Box as s } from "../../../foundation/utilities/primitives/Box.js";
+import { Range1 as c } from "../../../foundation/utilities/geometry/Range1.js";
+import { convertFromViewerCoordinates as l } from "../../../foundation/renderTarget/convertCoordinates.js";
+import { GroupThreeView as u } from "../../../foundation/views/GroupThreeView.js";
+import { updatePolygonOffset as d } from "../../../foundation/utilities/misc/defaultPolygonOffset.js";
+import { createSpriteWithText as f } from "../../../foundation/utilities/sprites/createSprite.js";
+import { PrimitivePickInfo as p } from "../common/PrimitivePickInfo.js";
+import { CircleGeometry as m, Color as h, DoubleSide as g, FrontSide as _, LineBasicMaterial as v, LineSegments as y, Mesh as b, MeshPhongMaterial as x, RingGeometry as S, Vector2 as C, Vector3 as w } from "three";
+import { CDF_TO_VIEWER_TRANSFORMATION as T, Vector3Pool as E } from "@cognite/reveal";
+import { LineMaterial as D } from "three/examples/jsm/lines/LineMaterial.js";
+import { Wireframe as O } from "three/examples/jsm/lines/Wireframe.js";
+//#region libs/shared/reveal-components/src/domains/primitives/box/BoxView.ts
+var k = new c(.6, .75), A = .2, j = .5, M = .15, N = new h(1, 1, 1), P = new a(2), F = 32, I = 100, L = class extends u {
+	_sprites = [];
+	_visibleFaces = [
+		,
+		,
+		,
+		,
+		,
+		,
+	];
+	get style() {
+		return super.style;
+	}
+	update(e) {
+		super.update(e), e.isChanged(t.selected, t.focus, t.renderStyle, t.color, t.unit) && (this.removeChildren(), this.invalidateBoundingBox(), this.invalidateRenderTarget());
+	}
+	beforeRender(e) {
+		super.beforeRender(e), !this.isEmpty && this.updateLabels(e);
+	}
+	get useDepthTest() {
+		let { domainObject: e } = this;
+		return e.focusType === n.Pending || e.isSelected ? !1 : this.style.depthTest;
+	}
+	addChildren() {
+		let { domainObject: e, style: t } = this, r = this.getMatrix(), { focusType: i } = e;
+		if (t.showSolid && this.addChild(this.createSolid(r)), t.showLines && (t.getLineWidth(e.isSelected) === 1 ? this.addChild(this.createLines(r)) : this.addChild(this.createWireframe(r))), z(i)) {
+			let e = this.getRotationMatrix();
+			this.addRotationRing(r, e), this.addEdgeCircles(r, e);
+		}
+		if (t.showLabel) this.addLabels(r);
+		else if (i === n.Rotation) {
+			let t = e.focusFace;
+			if (t !== void 0) {
+				let e = this.getTextHeight(this.style.relativeTextSize);
+				this.addChild(this.createRotationLabel(r, e, t));
+			}
+		}
+	}
+	intersectIfCloser(e, t) {
+		let { domainObject: r } = this;
+		if (r.focusType === n.Pending) return;
+		let i = this.getMatrix(), s = o.createOrientedBox(i), c = e.raycaster.ray, u = s.intersectRay(c, J());
+		if (u === null) return;
+		let d = u.distanceTo(c.origin);
+		if (t !== void 0 && t < d || r.hasClippingInIntersection && !e.isVisible(u)) return;
+		let f = J(u).applyMatrix4(i.invert()), m = new a().fromPositionAtFace(f);
+		if (!this.isFaceVisible(m)) return;
+		let h = new w(), g = l(u), _ = this.getPickedFocusType(g, m, h), v = {
+			type: "customObject",
+			point: u,
+			distanceToCamera: d,
+			userData: new p(m, _, h),
+			customObject: this,
+			domainObject: r
+		};
+		return this.shouldPickBoundingBox && (v.boundingBox = this.boundingBox), v;
+	}
+	getTextHeight(e) {
+		return e * this.domainObject.box.diagonal;
+	}
+	getFaceRadius(e) {
+		let { size: t } = this.domainObject.box;
+		return (t.getComponent(e.tangentIndex1) + t.getComponent(e.tangentIndex2)) / 4;
+	}
+	getMatrix() {
+		let { domainObject: e } = this, t = e.box.getMatrix();
+		return t.premultiply(T), t;
+	}
+	getRotationMatrix() {
+		let { domainObject: e } = this, t = e.box.getRotationMatrix();
+		return t.premultiply(T), t;
+	}
+	createSolid(e) {
+		let { domainObject: t, style: n } = this, r = new x();
+		B(r, t, n);
+		let i = o.createUnitGeometry(), a = new b(i, r);
+		return a.renderOrder = I, a.applyMatrix4(e), a;
+	}
+	createLines(e) {
+		let { domainObject: t, style: n } = this, r = new v();
+		V(r, t, n, this.useDepthTest);
+		let i = o.createLineSegmentsBufferGeometry(), a = new y(i, r);
+		return a.renderOrder = I, a.applyMatrix4(e), a;
+	}
+	createWireframe(e) {
+		let { domainObject: t, style: n } = this, r = new D();
+		H(r, t, n, this.useDepthTest);
+		let i = o.createLineSegmentsGeometry(), a = new O(i, r);
+		return a.renderOrder = I, a.applyMatrix4(e), a;
+	}
+	createRotationLabel(e, t, n) {
+		if (!this.isFaceVisible(n)) return;
+		let { domainObject: i } = this;
+		if (!i.canRotateComponent(n.index)) return;
+		let a = i.box.getRotationInDegrees(n.index);
+		if (a === 0) return;
+		let o = K(this.getUnitSystem().toStringWithUnit(a, r.Angle), this.style, t), s = n.getCenter(J());
+		return s.applyMatrix4(e), W(s, i, t), o.position.copy(s), o;
+	}
+	createPendingLabel(e, t, n) {
+		if (!this.isFaceVisible(n)) return;
+		let r = K("Pending", this.style, t), i = n.getCenter(J());
+		return i.applyMatrix4(e), W(i, this.domainObject, t), r.position.copy(i), r;
+	}
+	createRotationRing(e, t, n, r) {
+		let i = this.getFaceRadius(r), a = k.max * i, o = k.min * i, s = new S(o, a, F), c = new b(s, n);
+		c.renderOrder = I;
+		let l = r.getCenter(J());
+		return l.applyMatrix4(e), c.position.copy(l), G(c, r, t), c;
+	}
+	createEdgeCircle(e, t, n, r) {
+		let { domainObject: i } = this, a = i.box.size.getComponent(r.tangentIndex1);
+		if (!s.isValidSize(a)) return;
+		let o = i.box.size.getComponent(r.tangentIndex2);
+		if (!s.isValidSize(o)) return;
+		let c = Y(i) * this.getFaceRadius(r), l = new m(c, F);
+		n.transparent = !0, n.depthWrite = !1;
+		let u = new b(l, n);
+		u.renderOrder = I;
+		let d = r.getCenter(J());
+		return d.applyMatrix4(e), u.position.copy(d), G(u, r, t), u;
+	}
+	addLabels(t) {
+		let { domainObject: i, style: a } = this, o = this.getTextHeight(a.relativeTextSize);
+		e(this._sprites);
+		let c = this.getUnitSystem();
+		for (let e = 0; e < 3; e++) {
+			let t = i.box.size.getComponent(e);
+			if (!s.isValidSize(t)) {
+				this._sprites.push(void 0);
+				continue;
+			}
+			let n = K(c.toStringWithUnit(t, r.Length), a, o);
+			this._sprites.push(n), this.addChild(n);
+		}
+		let { focusType: l } = i;
+		l === n.Pending && i.box.hasArea ? this.addChild(this.createPendingLabel(t, o, P)) : R(l) && this.addChild(this.createRotationLabel(t, o, P));
+	}
+	updateLabels(e) {
+		let { domainObject: t, style: n } = this, r = this.getMatrix(), i = this.getRotationMatrix(), o = J(t.box.center);
+		o.applyMatrix4(T);
+		let s = e.getWorldPosition(J()), c = o.sub(s).normalize(), l = new a(), u = this._visibleFaces;
+		for (let e of a.getAllFaces(l)) {
+			let t = l.getNormal(J());
+			t.applyMatrix4(i), u[e.face] = t.dot(c) < 0;
+		}
+		let d = this.getTextHeight(n.relativeTextSize);
+		for (let e = 0; e < this._sprites.length; e++) {
+			let n = this._sprites[e];
+			if (n !== void 0) {
+				n.visible = !1;
+				for (let i = 0; i < 2; i++) {
+					let a = (e + (i === 0 ? 1 : 4)) % 6;
+					if (!u[a]) continue;
+					l.face = a;
+					let o = this.isFaceVisible(l), s = l.getCenter(J());
+					for (let i = 0; i < 2; i++) {
+						let a = (e + (i === 0 ? 2 : 5)) % 6;
+						if (!u[a] || (l.face = a, !o && !this.isFaceVisible(l))) continue;
+						let f = l.getCenter(J()).add(s);
+						f.applyMatrix4(r), W(f, t, d), f.addScaledVector(c, -d / 2), n.position.copy(f), n.visible = !0;
+						break;
+					}
+					if (n.visible) break;
+				}
+			}
+		}
+	}
+	addEdgeCircles(e, t) {
+		let { domainObject: r } = this, i = r.focusFace;
+		this.domainObject.focusType !== n.Face && (i = void 0);
+		let o = new x();
+		U(o, !1, this.useDepthTest);
+		for (let n of a.getAllFaces()) this.isFaceVisible(n) && (i !== void 0 && i.equals(n) || this.addChild(this.createEdgeCircle(e, t, o, n)));
+		if (i !== void 0 && this.isFaceVisible(i)) {
+			let n = new x();
+			U(n, !0, this.useDepthTest), this.addChild(this.createEdgeCircle(e, t, n, i));
+		}
+	}
+	addRotationRing(e, t) {
+		let { domainObject: r } = this, i = r.focusFace;
+		this.domainObject.focusType === n.Rotation ? i !== void 0 && !r.canRotateComponent(i.index) && (i = void 0) : i = void 0;
+		for (let n of a.getAllFaces()) {
+			if (!this.isFaceVisible(n) || !r.canRotateComponent(n.index) || i !== void 0 && i.equals(n)) continue;
+			let o = new x();
+			U(o, !1, this.useDepthTest), o.clippingPlanes = a.createClippingPlanes(e, n.index), this.addChild(this.createRotationRing(e, t, o, n));
+		}
+		if (i !== void 0 && this.isFaceVisible(i)) {
+			let n = new x();
+			U(n, !0, this.useDepthTest), n.clippingPlanes = a.createClippingPlanes(e, i.index), this.addChild(this.createRotationRing(e, t, n, i));
+		}
+	}
+	getPickedFocusType(e, t, r) {
+		let { domainObject: i } = this, a = J().setScalar(this.getFaceRadius(t)), o = i.box.getScaledMatrix(a);
+		o.invert();
+		let s = J(e).applyMatrix4(o), c = t.getPlanePoint(s).length();
+		if (c < Y(i)) return n.Face;
+		if (i.canMoveCorners()) {
+			r.copy(this.getCornerSign(e, t));
+			let i = this.getCorner(r, t);
+			if (e.distanceTo(i) < A * this.getFaceRadius(t)) return n.Corner;
+		}
+		return i.canRotateComponent(t.index) && k.isInside(c) ? n.Rotation : n.Body;
+	}
+	getCornerSign(e, t) {
+		let { domainObject: n } = this, r = J().setScalar(this.getFaceRadius(t)), i = n.box.getScaledMatrix(r);
+		i.invert();
+		let a = e.clone().applyMatrix4(i);
+		return a.setComponent(t.index, 0), a.setComponent(t.tangentIndex1, Math.sign(a.getComponent(t.tangentIndex1))), a.setComponent(t.tangentIndex2, Math.sign(a.getComponent(t.tangentIndex2))), a;
+	}
+	getCorner(e, t) {
+		let { domainObject: n } = this, r = t.getCenter(new w()).addScaledVector(e, .5), i = n.box.getMatrix();
+		return r.applyMatrix4(i), r;
+	}
+	isFaceVisible(e) {
+		let { domainObject: t } = this;
+		switch (t.primitiveType) {
+			case i.VerticalArea: return e.index === 1;
+			case i.HorizontalArea: return e.index === 2;
+		}
+		return !0;
+	}
+};
+function R(e) {
+	switch (e) {
+		case n.Face:
+		case n.Body:
+		case n.Pending: return !1;
+		default: return !0;
+	}
+}
+function z(e) {
+	switch (e) {
+		case n.Pending:
+		case n.None: return !1;
+		default: return !0;
+	}
+}
+function B(e, t, n) {
+	d(e);
+	let r = t.getColorByColorType(n.colorType);
+	e.color = r, e.opacity = n.getSolidOpacity(t.isSelected), e.transparent = !0, e.shininess = 100, e.emissive = r, e.emissiveIntensity = .2, e.side = g, e.flatShading = !0, e.depthWrite = !1, e.depthTest = n.depthTest;
+}
+function V(e, t, n, r) {
+	e.color = t.getColorByColorType(n.colorType), e.transparent = !0, e.depthWrite = !1, e.depthTest = r;
+}
+function H(e, t, n, r) {
+	e.color = t.getColorByColorType(n.colorType), e.transparent = !0, e.depthWrite = !1, e.depthTest = r, e.linewidth = n.getLineWidth(t.isSelected), e.resolution = new C(1e3, 1e3), e.worldUnits = !1;
+}
+function U(e, t, n) {
+	d(e), e.color = N, e.transparent = !0, e.emissive = N, e.emissiveIntensity = t ? .9 : .2, e.side = _, e.flatShading = !0, e.depthWrite = !1, e.depthTest = n;
+}
+function W(e, t, n) {
+	t.primitiveType !== i.VerticalArea && (e.y += 1.1 * n / 2);
+}
+function G(e, t, n) {
+	switch (e.rotation.setFromRotationMatrix(n), t.face) {
+		case 0:
+			e.rotateY(Math.PI / 2);
+			break;
+		case 3:
+			e.rotateY(-Math.PI / 2);
+			break;
+		case 2:
+			e.rotateY(0);
+			break;
+		case 5:
+			e.rotateY(Math.PI);
+			break;
+		case 1:
+			e.rotateX(-Math.PI / 2);
+			break;
+		case 4: e.rotateX(Math.PI / 2);
+	}
+}
+function K(e, t, n) {
+	let r = f(e, n, t.labelColor, t.labelBgColor);
+	return r.material.transparent = !0, r.material.opacity = t.labelOpacity, r.material.depthTest = t.depthTest, r.renderOrder = I, r;
+}
+var q = new E();
+function J(e) {
+	return q.getNext(e);
+}
+function Y(e) {
+	return e.primitiveType === i.Point ? j : M;
+}
+//#endregion
+export { L as BoxView, K as createSprite, G as rotateEdgeCircle, V as updateLineSegmentsMaterial, U as updateMarkerMaterial, B as updateSolidMaterial, H as updateWireframeMaterial };

package/dist/domains/primitives/common/BoxFace.d.ts

@@ -0,0 +1,68 @@
+import { Matrix4, Plane, Vector2, Vector3 } from 'three';
+/**
+ * Represents a face of a box.
+ *  Face is 0-5, where 0-2 are positive faces and 3-5 are negative faces as this:
+ *  Face 0, and 3 is towards X-axis
+ *  Face 1, and 4 is towards Y-axis
+ *  Face 2, and 5 is towards Z-axis
+ */
+export declare class BoxFace {
+    private _face;
+    constructor(face?: number);
+    get face(): number;
+    set face(value: number);
+    /**
+     * Gets the axis index corresponding to this face.
+     * @returns The axis index (0 for X, 1 for Y, 2 for Z).
+     */
+    get index(): number;
+    /**
+     * Gets the tangent index 1 corresponding to this face.
+     * @returns The axis index (0 for X, 1 for Y, 2 for Z).
+     */
+    get tangentIndex1(): number;
+    /**
+     * Gets the tangent index 2 corresponding to this face.
+     * @returns The axis index (0 for X, 1 for Y, 2 for Z).
+     */
+    get tangentIndex2(): number;
+    /**
+     * Gets the sign of the face.
+     * Returns `1` if the face index is less than 3, otherwise returns `-1`.
+     * This can be used to determine the orientation of the box face.
+     */
+    get sign(): number;
+    copy(other: BoxFace): this;
+    equals(other: BoxFace): boolean;
+    /**
+     * Determines the box face corresponding to the given position vector relative to the box center.
+     * The face is selected based on the axis with the largest absolute value in the position vector.
+     *
+     * - If the x component is largest, sets the face to 0 (positive x) or 3 (negative x).
+     * - If the y component is largest, sets the face to 1 (positive y) or 4 (negative y).
+     * - If the z component is largest, sets the face to 2 (positive z) or 5 (negative z).
+     *
+     * @param positionAtFace - The position vector relative to the box center.
+     * @returns The current instance with the updated face.
+     */
+    fromPositionAtFace(positionAtFace: Vector3): this;
+    /**
+     * Projects a 3D point onto the 2D plane corresponding to the current box face.
+     *
+     * The mapping of the 3D coordinates to 2D depends on the value of `this.face`:
+     * - For faces 1 and 4, returns (x, z).
+     * - For faces 2 and 5, returns (x, y).
+     * - For all other faces, returns (y, z).
+     *
+     * @param positionAtFace - The 3D position to project onto the face's plane.
+     * @returns A `Vector2` representing the projected 2D coordinates on the face's plane.
+     */
+    getPlanePoint(positionAtFace: Vector3): Vector2;
+    getNormal(target?: Vector3): Vector3;
+    getTangent1(target?: Vector3): Vector3;
+    getTangent2(target?: Vector3): Vector3;
+    getCenter(target?: Vector3): Vector3;
+    static getAllFaces(target?: BoxFace): Generator<BoxFace>;
+    static createClippingPlanes(matrix: Matrix4, exceptIndex?: number): Plane[];
+    static equals(face: BoxFace | undefined, other: BoxFace | undefined): boolean;
+}

package/dist/domains/primitives/common/BoxFace.js

@@ -0,0 +1,81 @@
+import { Plane as e, Vector2 as t, Vector3 as n } from "three";
+//#region libs/shared/reveal-components/src/domains/primitives/common/BoxFace.ts
+var r = class r {
+	_face = 0;
+	constructor(e = 0) {
+		if (!i(e)) throw Error("Invalid face in constructor " + e);
+		this._face = e;
+	}
+	get face() {
+		return this._face;
+	}
+	set face(e) {
+		if (!i(e)) throw Error("Invalid face in setter" + e);
+		this._face = e;
+	}
+	get index() {
+		return this._face % 3;
+	}
+	get tangentIndex1() {
+		return (this.index + 1) % 3;
+	}
+	get tangentIndex2() {
+		return (this.index + 2) % 3;
+	}
+	get sign() {
+		return this._face < 3 ? 1 : -1;
+	}
+	copy(e) {
+		return this._face = e._face, this;
+	}
+	equals(e) {
+		return this.face === e.face;
+	}
+	fromPositionAtFace(e) {
+		let t = Math.abs(e.x), n = Math.abs(e.y), r = Math.abs(e.z);
+		return this._face = t >= n && t >= r ? e.x > 0 ? 0 : 3 : n >= t && n >= r ? e.y > 0 ? 1 : 4 : e.z > 0 ? 2 : 5, this;
+	}
+	getPlanePoint(e) {
+		switch (this.face) {
+			case 1:
+			case 4: return new t(e.x, e.z);
+			case 2:
+			case 5: return new t(e.x, e.y);
+			default: return new t(e.y, e.z);
+		}
+	}
+	getNormal(e) {
+		return e === void 0 && (e = new n()), e.setScalar(0), e.setComponent(this.index, this.sign);
+	}
+	getTangent1(e) {
+		return e === void 0 && (e = new n()), e.setScalar(0), e.setComponent(this.tangentIndex1, 1);
+	}
+	getTangent2(e) {
+		return e === void 0 && (e = new n()), e.setScalar(0), e.setComponent(this.tangentIndex2, 1);
+	}
+	getCenter(e) {
+		return e === void 0 && (e = new n()), e.setScalar(0), e.setComponent(this.index, this.sign * .5);
+	}
+	static *getAllFaces(e) {
+		e === void 0 && (e = new r());
+		for (let t = 0; t < 6; t++) e.face = t, yield e;
+	}
+	static createClippingPlanes(t, i) {
+		let a = [], o = new n(), s = new n();
+		for (let n of r.getAllFaces()) {
+			if (i !== void 0 && n.index === i) continue;
+			n.getCenter(o), n.getNormal(s).negate();
+			let r = new e().setFromNormalAndCoplanarPoint(s, o);
+			r.applyMatrix4(t), a.push(r);
+		}
+		return a;
+	}
+	static equals(e, t) {
+		return e === void 0 ? t === void 0 : t !== void 0 && e.equals(t);
+	}
+};
+function i(e) {
+	return e >= 0 && e <= 5;
+}
+//#endregion
+export { r as BoxFace };

package/dist/domains/primitives/common/PrimitivePickInfo.d.ts

@@ -0,0 +1,27 @@
+import { Vector3 } from 'three';
+import { FocusType } from '../../../foundation/domainObjectsHelpers/FocusType';
+import { BoxFace } from './BoxFace';
+/**
+ * Represents information about a picked box.
+ */
+export declare class PrimitivePickInfo {
+    /**
+     * The face of the primitive that was picked.
+     */
+    readonly face: BoxFace;
+    /**
+     * The type of focus on the picked box.
+     */
+    readonly focusType: FocusType;
+    /**
+     * Indicates the corner of the face.
+     */
+    readonly cornerSign: Vector3;
+    /**
+     * Creates a new instance of PrimitivePickInfo.
+     * @param face The face of the box that was picked.
+     * @param focusType The type of focus on the picked box.
+     * @param cornerSign Indicates the corner of the face.
+     */
+    constructor(face: BoxFace, focusType: FocusType, cornerSign?: Vector3);
+}

package/dist/domains/primitives/common/PrimitivePickInfo.js

@@ -0,0 +1,12 @@
+import { Vector3 as e } from "three";
+//#region libs/shared/reveal-components/src/domains/primitives/common/PrimitivePickInfo.ts
+var t = class {
+	face;
+	focusType;
+	cornerSign;
+	constructor(t, n, r) {
+		this.face = t, this.focusType = n, this.cornerSign = r ?? new e();
+	}
+};
+//#endregion
+export { t as PrimitivePickInfo };

package/dist/domains/primitives/common/PrimitiveRenderStyle.d.ts

@@ -0,0 +1,12 @@
+import { Color } from 'three';
+import { ColorType } from '../../../foundation/domainObjectsHelpers/ColorType';
+import { CommonRenderStyle } from '../../../foundation/renderStyles/CommonRenderStyle';
+export declare abstract class PrimitiveRenderStyle extends CommonRenderStyle {
+    colorType: ColorType;
+    showLabel: boolean;
+    addLabels: boolean;
+    labelColor: Color;
+    labelBgColor: Color;
+    labelOpacity: number;
+    relativeTextSize: number;
+}

package/dist/domains/primitives/common/PrimitiveRenderStyle.js

@@ -0,0 +1,16 @@
+import { ColorType as e } from "../../../foundation/domainObjectsHelpers/ColorType.js";
+import { WHITE_COLOR as t } from "../../../foundation/utilities/colors/colorUtils.js";
+import { CommonRenderStyle as n } from "../../../foundation/renderStyles/CommonRenderStyle.js";
+import { Color as r } from "three";
+//#region libs/shared/reveal-components/src/domains/primitives/common/PrimitiveRenderStyle.ts
+var i = class extends n {
+	colorType = e.Specified;
+	showLabel = !0;
+	addLabels = !0;
+	labelColor = t.clone();
+	labelBgColor = new r("#232323");
+	labelOpacity = .9;
+	relativeTextSize = .05;
+};
+//#endregion
+export { i as PrimitiveRenderStyle };

package/dist/domains/primitives/common/SolidDomainObject.d.ts

@@ -0,0 +1,18 @@
+import { VisualDomainObject } from '../../../foundation/domainObjects/VisualDomainObject';
+import { FocusType } from '../../../foundation/domainObjectsHelpers/FocusType';
+import { Transaction } from '../../../foundation/undo/Transaction';
+import { PrimitiveType } from '../../../foundation/utilities/primitives/PrimitiveType';
+import { IconName } from '../../../foundation/utilities/types';
+import { BoxFace } from './BoxFace';
+import { SolidPrimitiveRenderStyle } from './SolidPrimitiveRenderStyle';
+export declare abstract class SolidDomainObject extends VisualDomainObject {
+    focusFace: BoxFace | undefined;
+    static GizmoOnly: string;
+    get renderStyle(): SolidPrimitiveRenderStyle;
+    protected constructor();
+    get icon(): IconName;
+    createTransaction(changed: symbol): Transaction;
+    setFocus(focusType: FocusType, focusFace?: BoxFace): boolean;
+    abstract get primitiveType(): PrimitiveType;
+    clear(): void;
+}

package/dist/domains/primitives/common/SolidDomainObject.js

@@ -0,0 +1,39 @@
+import { Changes as e } from "../../../foundation/domainObjectsHelpers/Changes.js";
+import { FocusType as t } from "../../../foundation/domainObjectsHelpers/FocusType.js";
+import { VisualDomainObject as n } from "../../../foundation/domainObjects/VisualDomainObject.js";
+import { DomainObjectTransaction as r } from "../../../foundation/undo/DomainObjectTransaction.js";
+import { getIconByPrimitiveType as i } from "../../../foundation/utilities/primitives/getIconByPrimitiveType.js";
+import { BoxFace as a } from "./BoxFace.js";
+//#region libs/shared/reveal-components/src/domains/primitives/common/SolidDomainObject.ts
+var o = class extends n {
+	focusFace = void 0;
+	static GizmoOnly = "GizmoOnly";
+	get renderStyle() {
+		return this.getRenderStyle();
+	}
+	constructor() {
+		super();
+	}
+	get icon() {
+		return i(this.primitiveType);
+	}
+	createTransaction(e) {
+		return new r(this, e);
+	}
+	setFocus(n, r) {
+		let i = this.focusType === t.Pending && n !== t.Pending;
+		if (n === t.None) {
+			if (this.focusType === t.None) return !1;
+			this.focusType = t.None, this.focusFace = void 0;
+		} else {
+			if (n === this.focusType && a.equals(this.focusFace, r)) return !1;
+			this.focusType = n, this.focusFace = r;
+		}
+		return this.notify(e.focus), i && this.notify(e.geometry), !0;
+	}
+	clear() {
+		this.focusType = t.None, this.focusFace = void 0;
+	}
+};
+//#endregion
+export { o as SolidDomainObject };

package/dist/domains/primitives/common/SolidPrimitiveRenderStyle.d.ts

@@ -0,0 +1,18 @@
+import { Color } from 'three';
+import { RenderStyle } from '../../../foundation/renderStyles/RenderStyle';
+import { PrimitiveRenderStyle } from './PrimitiveRenderStyle';
+export declare class SolidPrimitiveRenderStyle extends PrimitiveRenderStyle {
+    showLines: boolean;
+    lineWidth: number;
+    selectedLineWidth: number;
+    lineColor: Color;
+    selectedLineColor: Color;
+    showSolid: boolean;
+    solidOpacityUse: boolean;
+    selectedSolidOpacity: number;
+    solidOpacity: number;
+    clone(): RenderStyle;
+    getSolidOpacity(isSelected: boolean): number;
+    getLineWidth(isSelected: boolean): number;
+    getLineColor(isSelected: boolean): Color;
+}

package/dist/domains/primitives/common/SolidPrimitiveRenderStyle.js

@@ -0,0 +1,29 @@
+import { BLACK_COLOR as e, WHITE_COLOR as t } from "../../../foundation/utilities/colors/colorUtils.js";
+import { PrimitiveRenderStyle as n } from "./PrimitiveRenderStyle.js";
+import { cloneDeep as r } from "lodash-es";
+//#region libs/shared/reveal-components/src/domains/primitives/common/SolidPrimitiveRenderStyle.ts
+var i = class extends n {
+	showLines = !0;
+	lineWidth = 1;
+	selectedLineWidth = 1;
+	lineColor = e.clone();
+	selectedLineColor = t.clone();
+	showSolid = !0;
+	solidOpacityUse = !0;
+	selectedSolidOpacity = .5;
+	solidOpacity = this.selectedSolidOpacity / 4;
+	clone() {
+		return r(this);
+	}
+	getSolidOpacity(e) {
+		return this.solidOpacityUse ? e ? this.selectedSolidOpacity : this.solidOpacity : 1;
+	}
+	getLineWidth(e) {
+		return e ? this.selectedLineWidth : this.lineWidth;
+	}
+	getLineColor(e) {
+		return e ? this.selectedLineColor : this.lineColor;
+	}
+};
+//#endregion
+export { i as SolidPrimitiveRenderStyle };

package/dist/domains/primitives/cylinder/CylinderCreator.d.ts

@@ -0,0 +1,27 @@
+import { Ray, Vector3 } from 'three';
+import { DomainObject } from '../../../foundation/domainObjects/DomainObject';
+import { BaseCreator } from '../../../foundation/domainObjectsHelpers/BaseCreator';
+import { PrimitiveType } from '../../../foundation/utilities/primitives/PrimitiveType';
+import { CylinderDomainObject } from './CylinderDomainObject';
+/**
+ * Helper class for generate a CylinderDomainObject by clicking around
+ * Here is the way it works:
+ * * - The first point will be one side of the cylinder
+ * * - The second point will be the other side of the cylinder, so the diameter will be the distance between the first 2 point
+ *     and the one of the end center points will be the average of the first 2 points.
+ *     Here we also calculate the axis of to horizontal cylinder. The vertical cylinder will always have the axis as UP_VECTOR.
+ * * - The third point will be the height of the cylinder.
+ */
+export declare class CylinderCreator extends BaseCreator {
+    private readonly _domainObject;
+    private readonly _primitiveType;
+    constructor(domainObject: CylinderDomainObject, primitiveType?: PrimitiveType);
+    get preferIntersection(): boolean;
+    get domainObject(): DomainObject;
+    get minimumPointCount(): number;
+    get maximumPointCount(): number;
+    protected addPointCore(ray: Ray, point: Vector3 | undefined, isPending: boolean): boolean;
+    private recalculatePoint;
+    private rebuild;
+    private setCenter;
+}