@cognite/reveal-components 1.0.0

package/dist/domains/primitives/cylinder/CylinderCreator.js

@@ -0,0 +1,79 @@
+import { Changes as e } from "../../../foundation/domainObjectsHelpers/Changes.js";
+import { FocusType as t } from "../../../foundation/domainObjectsHelpers/FocusType.js";
+import { PrimitiveType as n } from "../../../foundation/utilities/primitives/PrimitiveType.js";
+import { getClosestPointOnLine as r } from "../../../foundation/utilities/extensions/rayUtils.js";
+import { horizontalDistanceTo as i, rotatePiHalf as a } from "../../../foundation/utilities/extensions/vectorUtils.js";
+import { Cylinder as o } from "../../../foundation/utilities/primitives/Cylinder.js";
+import { BaseCreator as s } from "../../../foundation/domainObjectsHelpers/BaseCreator.js";
+import { Plane as c, Vector3 as l } from "three";
+//#region libs/shared/reveal-components/src/domains/primitives/cylinder/CylinderCreator.ts
+var u = new l(0, 0, 1), d = class extends s {
+	_domainObject;
+	_primitiveType;
+	constructor(e, n) {
+		super(), this._primitiveType = n ?? e.primitiveType, this._domainObject = e, this._domainObject.focusType = t.Pending;
+	}
+	get preferIntersection() {
+		return this._domainObject.primitiveType === n.HorizontalCylinder ? this.pointCount <= 2 : this.pointCount <= 1;
+	}
+	get domainObject() {
+		return this._domainObject;
+	}
+	get minimumPointCount() {
+		return this.maximumPointCount;
+	}
+	get maximumPointCount() {
+		return this._domainObject.primitiveType === n.HorizontalCircle ? 2 : 3;
+	}
+	addPointCore(n, r, i) {
+		let a = this._domainObject;
+		return r = this.recalculatePoint(r, n), r !== void 0 && (this.addRawPoint(r, i), this.rebuild(n), a.notify(e.geometry), this.isFinished && a.setFocus(t.Focus), !0);
+	}
+	recalculatePoint(e, t) {
+		if (this.notPendingPointCount === 1) {
+			if (e !== void 0) return this._primitiveType !== n.HorizontalCylinder && (e.z = this.firstPoint.z), e;
+			if (this._primitiveType === n.HorizontalCylinder) return;
+			{
+				let e = new c().setFromNormalAndCoplanarPoint(u, this.firstPoint), n = t.intersectPlane(e, new l());
+				if (n !== null) return n.z = this.firstPoint.z, n;
+			}
+			return;
+		}
+		if (this.notPendingPointCount === 2) {
+			let { center: e, axis: n } = this._domainObject.cylinder;
+			return r(t, n, e);
+		}
+		return e;
+	}
+	rebuild(e) {
+		if (this.pointCount === 0) throw Error("Cannot create a cylinder without points");
+		let { cylinder: t } = this._domainObject;
+		if (this.pointCount === 1) {
+			if (this._primitiveType === n.HorizontalCylinder) {
+				let t = new l();
+				f(t, e), this.setCenter(this.firstPoint, t);
+			} else this.setCenter(this.firstPoint, u);
+		} else if (this.pointCount === 2) {
+			let r = this.firstPoint.clone().add(this.lastPoint).multiplyScalar(.5);
+			if (this._domainObject.primitiveType === n.HorizontalCylinder) {
+				let n = this.firstPoint.clone().sub(this.lastPoint);
+				a(n), f(n, e), this.setCenter(r, n);
+				let i = new c().setFromNormalAndCoplanarPoint(n, r), o = i.projectPoint(this.firstPoint, new l()), s = i.projectPoint(this.lastPoint, new l());
+				t.radius = o.distanceTo(s) / 2;
+			} else this.setCenter(r, u), t.radius = i(this.firstPoint, this.lastPoint) / 2;
+		} else if (this.pointCount === 3) {
+			let e = this.firstPoint.clone().add(this.points[1]).multiplyScalar(.5);
+			t.centerA.copy(e), t.centerB.copy(this.lastPoint);
+		}
+		t.forceMinSize();
+	}
+	setCenter(e, t) {
+		let { cylinder: n } = this._domainObject, { centerA: r, centerB: i } = n;
+		r.copy(e), i.copy(e), r.addScaledVector(t, -o.HalfMinSize), i.addScaledVector(t, +o.HalfMinSize), n.forceMinSize();
+	}
+};
+function f(e, t) {
+	e.z = 0, e.length() === 0 && (e.copy(t.direction), e.z = 0, e.length() === 0 && e.set(1, 0, 0)), e.normalize();
+}
+//#endregion
+export { d as CylinderCreator };

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

@@ -0,0 +1,26 @@
+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 { Cylinder } from '../../../foundation/utilities/primitives/Cylinder';
+import { PrimitiveType } from '../../../foundation/utilities/primitives/PrimitiveType';
+import { TranslationInput } from '../../../foundation/utilities/translation/TranslateInput';
+import { SolidDomainObject } from '../common/SolidDomainObject';
+export declare abstract class CylinderDomainObject extends SolidDomainObject {
+    readonly cylinder: Cylinder;
+    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: CylinderDomainObject, what?: symbol): void;
+    getEditToolCursor(renderTarget: RevealRenderTarget, point?: Vector3): string | undefined;
+    get primitiveType(): PrimitiveType;
+    clear(): void;
+    get canMoveCaps(): boolean;
+    expandBoundingBox(boundingBox: Box3): void;
+}

package/dist/domains/primitives/cylinder/CylinderDomainObject.js

@@ -0,0 +1,98 @@
+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 { PanelInfo as o } from "../../../foundation/domainObjectsHelpers/PanelInfo.js";
+import { SolidPrimitiveRenderStyle as s } from "../common/SolidPrimitiveRenderStyle.js";
+import { Cylinder as c } from "../../../foundation/utilities/primitives/Cylinder.js";
+import { CylinderDragger as l } from "./CylinderDragger.js";
+import { Line3 as u, Vector3 as d } from "three";
+//#region libs/shared/reveal-components/src/domains/primitives/cylinder/CylinderDomainObject.ts
+var f = class extends a {
+	cylinder = new c();
+	_primitiveType;
+	constructor(e = r.Cylinder) {
+		super(), i(p, e), this._primitiveType = e;
+	}
+	get typeName() {
+		switch (this.primitiveType) {
+			case r.HorizontalCylinder: return { key: "CYLINDER_HORIZONTAL" };
+			case r.VerticalCylinder: return { key: "CYLINDER_VERTICAL" };
+			case r.Cylinder: return { key: "CYLINDER" };
+			case r.HorizontalCircle: return { key: "CIRCLE" };
+			case r.Diameter: return { key: "DIAMETER" };
+			default: throw Error("Unknown PrimitiveType");
+		}
+	}
+	createRenderStyle() {
+		return new s();
+	}
+	createDragger(e) {
+		if (e.intersection.userData !== void 0) return new l(e, this);
+	}
+	get hasPanelInfo() {
+		return !0;
+	}
+	getPanelInfo() {
+		let i = new o(), { cylinder: a } = this, s = this.focusType !== t.Pending, l = c.isValidSize(a.radius), u = c.isValidSize(a.height) && this.primitiveType !== r.HorizontalCircle;
+		return l && d({ key: "DIAMETER" }, a.diameter, n.Length, (t) => {
+			let n = t / 2;
+			n !== a.radius && (a.radius = n, this.notify(e.geometry));
+		}, m), u && d({ key: "HEIGHT" }, a.height, n.Length, (t) => {
+			t !== a.height && (a.height = t, this.notify(e.geometry));
+		}, h), l && (d({ key: "RADIUS" }, a.radius, n.Length), this.primitiveType === r.HorizontalCircle ? d({ key: "AREA" }, a.endCapArea, n.Area) : d({ key: "AREA" }, a.area, n.Area)), l && u && d({ key: "VOLUME" }, a.volume, n.Volume), i;
+		function d(e, t, n, r, a) {
+			i.add({
+				translationInput: e,
+				value: t,
+				quantity: n,
+				setValue: s ? r : void 0,
+				verifyValue: s ? a : void 0
+			});
+		}
+	}
+	copyFrom(t, n) {
+		super.copyFrom(t, n), (n === void 0 || n === e.geometry) && this.cylinder.copy(t.cylinder);
+	}
+	getEditToolCursor(e, n) {
+		if (this.focusType === t.Body) return "move";
+		if (this.focusType === t.Face) {
+			if (this.focusFace === void 0) return;
+			let { cylinder: t } = this;
+			if (this.focusFace.index === 2) return e.getResizeCursor(t.centerA, t.centerB);
+			{
+				if (n === void 0) return;
+				let r = new u(t.centerA, t.centerB).closestPointToPoint(n, !1, new d());
+				return e.getResizeCursor(n, r);
+			}
+		}
+		if (this.focusType === t.Rotation) return "grab";
+	}
+	get primitiveType() {
+		return this._primitiveType;
+	}
+	clear() {
+		super.clear(), this.cylinder.clear();
+	}
+	get canMoveCaps() {
+		return this.primitiveType === r.Cylinder || this.primitiveType === r.Diameter || this.primitiveType === r.HorizontalCylinder;
+	}
+	expandBoundingBox(e) {
+		this.cylinder.expandBoundingBox(e);
+	}
+}, p = [
+	r.Diameter,
+	r.Cylinder,
+	r.HorizontalCircle,
+	r.HorizontalCylinder,
+	r.VerticalCylinder
+];
+function m(e) {
+	return c.isValidSize(e / 2);
+}
+function h(e) {
+	return c.isValidSize(e);
+}
+//#endregion
+export { f as CylinderDomainObject };

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

@@ -0,0 +1,32 @@
+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 { CylinderDomainObject } from './CylinderDomainObject';
+/**
+ * The `CylinderDragger` class represents a utility for dragging and manipulating a cylinder 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 CylinderDragger extends BaseDragger {
+    private readonly _domainObject;
+    private readonly _face;
+    private readonly _focusType;
+    private readonly _normal;
+    private readonly _planeOfFace;
+    private readonly _originalCylinder;
+    get face(): BoxFace;
+    get focusType(): FocusType;
+    constructor(props: CreateDraggerProps, domainObject: CylinderDomainObject);
+    get domainObject(): VisualDomainObject;
+    onPointerDown(_event: PointerEvent): void;
+    onPointerDrag(event: PointerEvent, ray: Ray): boolean;
+    private applyByFocusType;
+    private translate;
+    private moveFace;
+    private moveRadius;
+    private moveEndCaps;
+    private moveAlongAxis;
+    private rotate;
+}

package/dist/domains/primitives/cylinder/CylinderDragger.js

@@ -0,0 +1,112 @@
+import { Changes as e } from "../../../foundation/domainObjectsHelpers/Changes.js";
+import { FocusType as t } from "../../../foundation/domainObjectsHelpers/FocusType.js";
+import { isAbsEqual as n } from "../../../foundation/utilities/extensions/mathUtils.js";
+import { PrimitiveType as r } from "../../../foundation/utilities/primitives/PrimitiveType.js";
+import { BaseDragger as i } from "../../../foundation/domainObjectsHelpers/BaseDragger.js";
+import { getClosestPointOnLine as a } from "../../../foundation/utilities/extensions/rayUtils.js";
+import { Cylinder as o } from "../../../foundation/utilities/primitives/Cylinder.js";
+import { Line3 as s, Plane as c, Vector3 as l } from "three";
+import { Vector3Pool as u } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/domains/primitives/cylinder/CylinderDragger.ts
+var d = class extends i {
+	_domainObject;
+	_face;
+	_focusType;
+	_normal = new l();
+	_planeOfFace = new c();
+	_originalCylinder = new o();
+	get face() {
+		return this._face;
+	}
+	get focusType() {
+		return this._focusType;
+	}
+	constructor(e, t) {
+		super(e, t);
+		let n = e.intersection.userData;
+		if (this._domainObject = t, this._face = n.face, this._focusType = n.focusType, this._face.index === 2) {
+			this._face.getNormal(this._normal);
+			let e = t.cylinder.getRotationMatrix();
+			this._normal.applyMatrix4(e), this._normal.normalize(), this._planeOfFace.setFromNormalAndCoplanarPoint(this._normal, this.point);
+		}
+		this._originalCylinder.copy(t.cylinder);
+	}
+	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.Body: return this.translate(n);
+			case t.Rotation: return this.rotate(n);
+			default: return !1;
+		}
+	}
+	translate(e) {
+		if (this._face.index !== 2) return !1;
+		let t = e.intersectPlane(this._planeOfFace, p());
+		if (t === null) return !1;
+		let n = t.sub(this.point);
+		if (n.length() < 1e-6) return !1;
+		let { cylinder: r } = this._domainObject, i = this._originalCylinder;
+		return r.copy(i), r.centerA.add(n), r.centerB.add(n), !0;
+	}
+	moveFace(e, t) {
+		return this._face.index === 2 ? this._domainObject.primitiveType === r.HorizontalCircle ? this.moveAlongAxis(e) : this.moveEndCaps(e, t) : this.moveRadius(e, t);
+	}
+	moveRadius(e, t) {
+		let { cylinder: r } = this._domainObject, i = new s(r.centerA, r.centerB).closestPointToPoint(this.point, !0, p()), c = p().subVectors(i, this.point).normalize(), l = a(e, c, i).distanceTo(i), u = this.getBestValue(l, t, o.MinSize);
+		return !n(u, r.radius, 1e-6) && (r.radius = u, !0);
+	}
+	moveEndCaps(e, t) {
+		let n = p();
+		a(e, this._normal, this.point, n);
+		let r = this._planeOfFace.distanceToPoint(n);
+		if (Math.abs(r) < 1e-6) return !1;
+		let i = this._originalCylinder, s = this.getBestValue(i.height + r, t, o.MinSize);
+		if (Math.abs(s - i.height) < 1e-6) return !1;
+		let { cylinder: c } = this._domainObject;
+		c.copy(i);
+		let { centerA: l, centerB: u } = c, d = p().subVectors(l, u).normalize().multiplyScalar(s);
+		return this._face.face === 2 ? u.subVectors(l, d) : l.addVectors(u, d), !0;
+	}
+	moveAlongAxis(e) {
+		let t = p();
+		a(e, this._normal, this.point, t);
+		let n = this._planeOfFace.distanceToPoint(t), r = this._originalCylinder, { cylinder: i } = this._domainObject;
+		i.copy(r);
+		let { centerA: o, centerB: s } = i, c = p().subVectors(o, s).normalize().multiplyScalar(n);
+		return this._face.face === 2 && c.negate(), c.length() < 1e-6 ? !1 : (o.add(c), s.add(c), !0);
+	}
+	rotate(e) {
+		if (this._face.index !== 2) return !1;
+		let t = e.intersectPlane(this._planeOfFace, p());
+		if (t === null) return !1;
+		let n = p().subVectors(t, this.point);
+		if (n.length() < 1e-6) return !1;
+		let { cylinder: i, primitiveType: a } = this._domainObject, o = this._originalCylinder;
+		i.copy(o);
+		let { centerA: s, centerB: c } = i;
+		if (a === r.HorizontalCylinder && (n.z = 0), this._face.face === 2) {
+			c.add(n);
+			let e = p().subVectors(s, c).normalize().multiplyScalar(o.height);
+			c.subVectors(s, e);
+		} else {
+			s.add(n);
+			let e = p().subVectors(s, c).normalize().multiplyScalar(o.height);
+			s.addVectors(c, e);
+		}
+		return !0;
+	}
+}, f = new u();
+function p(e) {
+	return f.getNext(e);
+}
+//#endregion
+export { d as CylinderDragger };

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

@@ -0,0 +1,30 @@
+import { PerspectiveCamera } from 'three';
+import { CustomObjectIntersectInput, CustomObjectIntersection } from '@cognite/reveal';
+import { DomainObjectChange } from '../../../foundation/domainObjectsHelpers/DomainObjectChange';
+import { GroupThreeView } from '../../../foundation/views/GroupThreeView';
+import { SolidPrimitiveRenderStyle } from '../common/SolidPrimitiveRenderStyle';
+import { CylinderDomainObject } from './CylinderDomainObject';
+export declare class CylinderView extends GroupThreeView<CylinderDomainObject> {
+    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 getFaceRadius;
+    private getMatrix;
+    private createSolid;
+    private createLines;
+    private createWireframe;
+    private createRotationRing;
+    private createEdgeCircle;
+    private addEdgeCircles;
+    private addLabels;
+    private createDiameterLabel;
+    private createHeightLabel;
+    private getDiameterLabelHeight;
+    private getHeightLabelHeight;
+    private createLabel;
+    private updateLabels;
+    private getPickedFocusType;
+}

package/dist/domains/primitives/cylinder/CylinderView.js

@@ -0,0 +1,185 @@
+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 } from "../../../foundation/utilities/primitives/PrimitiveType.js";
+import { BoxFace as i } from "../common/BoxFace.js";
+import { Range1 as a } from "../../../foundation/utilities/geometry/Range1.js";
+import { Cylinder as o } from "../../../foundation/utilities/primitives/Cylinder.js";
+import { VIEWER_TO_CDF_TRANSFORMATION as s, convertFromViewerCoordinates as c } from "../../../foundation/renderTarget/convertCoordinates.js";
+import { CylinderUtils as l } from "../../../foundation/utilities/primitives/CylinderUtils.js";
+import { GroupThreeView as u } from "../../../foundation/views/GroupThreeView.js";
+import { PrimitivePickInfo as d } from "../common/PrimitivePickInfo.js";
+import { createSprite as f, rotateEdgeCircle as p, updateLineSegmentsMaterial as m, updateMarkerMaterial as h, updateSolidMaterial as g, updateWireframeMaterial as _ } from "../box/BoxView.js";
+import { CircleGeometry as v, LineBasicMaterial as y, LineSegments as b, Mesh as x, MeshPhongMaterial as S, RingGeometry as C } from "three";
+import { CDF_TO_VIEWER_TRANSFORMATION as w, Vector3Pool as T } from "@cognite/reveal";
+import { LineMaterial as E } from "three/examples/jsm/lines/LineMaterial.js";
+import { Wireframe as D } from "three/examples/jsm/lines/Wireframe.js";
+//#region libs/shared/reveal-components/src/domains/primitives/cylinder/CylinderView.ts
+var O = .2, k = .9, A = new a(.4, .7), j = 32, M = 1.1, N = .99, P = "HeightLabel", F = "DiameterLabelA", I = "DiameterLabelB", L = 100, R = 101, z = class extends u {
+	get style() {
+		return super.style;
+	}
+	update(t) {
+		super.update(t), t.isChanged(e.selected, e.focus, e.renderStyle, e.color, e.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 === t.Pending || e.isSelected ? !1 : this.style.depthTest;
+	}
+	addChildren() {
+		let { domainObject: e, style: t } = this, n = this.getMatrix(), { focusType: r } = e;
+		t.showSolid && this.addChild(this.createSolid(n)), t.showLines && (t.getLineWidth(e.isSelected) === 1 ? this.addChild(this.createLines(n)) : this.addChild(this.createWireframe(n))), B(r) && (e.canMoveCaps && (this.addChild(this.createRotationRing(n, new i(2))), this.addChild(this.createRotationRing(n, new i(5)))), this.addEdgeCircles(n)), t.showLabel && this.addLabels();
+	}
+	intersectIfCloser(e, n) {
+		let { domainObject: r } = this;
+		if (r.focusType === t.Pending) return;
+		let { cylinder: a } = r, o = H(a.centerA), s = H(a.centerB);
+		o.applyMatrix4(w), s.applyMatrix4(w);
+		let l = e.raycaster.ray, u = a.intersectRay(l, w);
+		if (u === void 0) return;
+		let f = this.getMatrix(), p = u.distanceTo(l.origin);
+		if (n !== void 0 && n < p || r.hasClippingInIntersection && !e.isVisible(u)) return;
+		let m = H(u).applyMatrix4(f.invert()), h = new i().fromPositionAtFace(m), g = c(u), _ = this.getPickedFocusType(g, h), v = {
+			type: "customObject",
+			point: u,
+			distanceToCamera: p,
+			userData: new d(h, _),
+			customObject: this,
+			domainObject: r
+		};
+		return this.shouldPickBoundingBox && (v.boundingBox = this.boundingBox), v;
+	}
+	getFaceRadius() {
+		return this.domainObject.cylinder.radius / 2;
+	}
+	getMatrix() {
+		let { domainObject: e } = this, t = e.cylinder.getMatrix();
+		return t.premultiply(w), t;
+	}
+	createSolid(e) {
+		let { domainObject: t } = this, { style: n } = this, r = new S();
+		g(r, t, n);
+		let i = l.createUnitGeometry();
+		i.applyMatrix4(s);
+		let a = new x(i, r);
+		return a.renderOrder = L, a.applyMatrix4(e), a;
+	}
+	createLines(e) {
+		let { domainObject: t } = this, { style: n } = this, r = new y();
+		m(r, t, n, this.useDepthTest);
+		let i = l.createLineSegmentsBufferGeometry(), a = new b(i, r);
+		return a.renderOrder = L, a.applyMatrix4(e), a;
+	}
+	createWireframe(e) {
+		let { domainObject: t } = this, { style: n } = this, r = new E();
+		_(r, t, n, this.useDepthTest);
+		let i = l.createLineSegmentsGeometry(), a = new D(i, r);
+		return a.renderOrder = L, a.applyMatrix4(e), a;
+	}
+	createRotationRing(e, n) {
+		if (!U(n)) return;
+		let { domainObject: r } = this, { focusType: i } = r, a = this.getFaceRadius(), o = A.max * 2 * a, s = A.min * 2 * a, c = new C(s, o, j), l = new S();
+		h(l, i === t.Rotation, this.useDepthTest);
+		let u = new x(c, l);
+		u.renderOrder = L;
+		let d = n.getCenter(H());
+		d.applyMatrix4(e), u.position.copy(d);
+		let f = r.cylinder.getRotationMatrix();
+		return f.premultiply(w), p(u, n, f), u;
+	}
+	createEdgeCircle(e, t, n) {
+		let { domainObject: r } = this, i = 2 * O * this.getFaceRadius(), a = new v(i, j);
+		t.transparent = !0, t.depthWrite = !1;
+		let o = new x(a, t);
+		o.renderOrder = L;
+		let s = n.getCenter(H());
+		s.applyMatrix4(e), o.position.copy(s);
+		let c = r.cylinder.getRotationMatrix();
+		return c.premultiply(w), p(o, n, c), o;
+	}
+	addEdgeCircles(e) {
+		let { domainObject: n } = this, r = n.focusFace;
+		this.domainObject.focusType !== t.Face && (r = void 0);
+		let a = new S();
+		h(a, !1, this.useDepthTest);
+		for (let t of i.getAllFaces()) U(t) && (r === void 0 || !r.equals(t)) && this.addChild(this.createEdgeCircle(e, a, t));
+		if (r !== void 0 && U(r)) {
+			let t = new S();
+			h(t, !0, this.useDepthTest), this.addChild(this.createEdgeCircle(e, t, r));
+		}
+	}
+	addLabels() {
+		let e = this.domainObject.primitiveType;
+		(e === r.Diameter || e === r.VerticalCylinder || e === r.HorizontalCircle || e === r.HorizontalCylinder) && (this.addChild(this.createDiameterLabel(I)), this.addChild(this.createDiameterLabel(F))), (e === r.VerticalCylinder || e === r.HorizontalCylinder) && this.addChild(this.createHeightLabel(P));
+	}
+	createDiameterLabel(e) {
+		let { cylinder: t } = this.domainObject;
+		if (t.radius < o.MinSize * N) return;
+		let n = this.getDiameterLabelHeight();
+		return this.createLabel(e, t.diameter, n);
+	}
+	createHeightLabel(e) {
+		let t = this.domainObject.cylinder.height;
+		if (t < o.MinSize * N) return;
+		let n = this.getHeightLabelHeight();
+		return this.createLabel(e, t, n);
+	}
+	getDiameterLabelHeight() {
+		let { style: e, domainObject: t } = this;
+		return 2 * e.relativeTextSize * t.cylinder.diameter;
+	}
+	getHeightLabelHeight() {
+		let { style: e, domainObject: t } = this;
+		return 2 * e.relativeTextSize * t.cylinder.height;
+	}
+	createLabel(e, t, r) {
+		let i = this.getUnitSystem().toStringWithUnit(t, n.Length), a = f(i, this.style, r);
+		return a.name = e, a.renderOrder = R, a;
+	}
+	updateLabels(e) {
+		let t = this._group.getObjectByName(F), n = this._group.getObjectByName(I), r = this._group.getObjectByName(P);
+		if (t === void 0 && n === void 0 && r === void 0) return;
+		let { cylinder: i } = this.domainObject, a = H(i.centerA), o = H(i.centerB);
+		a.applyMatrix4(w), o.applyMatrix4(w);
+		let s = H().subVectors(o, a).normalize(), c = e.getWorldPosition(H());
+		if (t !== void 0 && l(a, t, -1, this.getDiameterLabelHeight()), n !== void 0 && l(o, n, 1, this.getDiameterLabelHeight()), r !== void 0) {
+			let e = H().addVectors(a, o).multiplyScalar(.5);
+			r !== void 0 && u(e, r);
+		}
+		function l(e, t, n, r) {
+			let a = H().subVectors(e, c).normalize();
+			if (t.visible = Math.sign(s.dot(a)) !== n, !t.visible) return;
+			let o = H().crossVectors(a, s).normalize(), l = H(e).addScaledVector(o, .5 * i.radius);
+			l.addScaledVector(s, .5 * n * M * r), t.position.copy(l);
+		}
+		function u(e, t) {
+			let n = H().subVectors(e, c).normalize(), r = H().crossVectors(n, s).normalize(), a = H().crossVectors(r, s).normalize();
+			t.position.copy(e), t.position.addScaledVector(a, i.radius), t.visible = !0;
+		}
+	}
+	getPickedFocusType(e, n) {
+		let { domainObject: i } = this, a = H().setScalar(this.getFaceRadius()), o = i.cylinder.getScaledMatrix(a);
+		o.invert();
+		let s = H(e).applyMatrix4(o), c = n.getPlanePoint(s).length() / 2;
+		return !U(n) || c < O ? t.Face : i.canMoveCaps && A.isInside(c) ? t.Rotation : c > k && i.primitiveType === r.HorizontalCircle ? (n.face = 0, t.Face) : t.Body;
+	}
+};
+function B(e) {
+	switch (e) {
+		case t.Pending:
+		case t.None: return !1;
+		default: return !0;
+	}
+}
+var V = new T();
+function H(e) {
+	return V.getNext(e);
+}
+function U(e) {
+	return e.index === 2;
+}
+//#endregion
+export { z as CylinderView };

package/dist/domains/primitives/line/LineCreator.d.ts

@@ -0,0 +1,20 @@
+import { Ray, Vector3 } from 'three';
+import { DomainObject } from '../../../foundation/domainObjects/DomainObject';
+import { BaseCreator } from '../../../foundation/domainObjectsHelpers/BaseCreator';
+import { UndoManager } from '../../../foundation/undo/UndoManager';
+import { LineDomainObject } from './LineDomainObject';
+/**
+ * Helper class for generate a LineDomainObject by clicking around
+ */
+export declare class LineCreator extends BaseCreator {
+    private readonly _domainObject;
+    private readonly _undoManager?;
+    constructor(domainObject: LineDomainObject, undoManager?: UndoManager);
+    get preferIntersection(): boolean;
+    get domainObject(): DomainObject;
+    get minimumPointCount(): number;
+    get maximumPointCount(): number;
+    protected addPointCore(ray: Ray, point: Vector3 | undefined, isPending: boolean): boolean;
+    escape(): boolean;
+    protected transformInputPoint(ray: Ray, point: Vector3 | undefined, isPending: boolean): Vector3 | undefined;
+}

package/dist/domains/primitives/line/LineCreator.js

@@ -0,0 +1,53 @@
+import { copy as e } from "../../../foundation/utilities/extensions/arrayUtils.js";
+import { getRenderTarget as t } from "../../../foundation/domainObjects/getRoot.js";
+import { Changes as n } from "../../../foundation/domainObjectsHelpers/Changes.js";
+import { FocusType as r } from "../../../foundation/domainObjectsHelpers/FocusType.js";
+import { PrimitiveType as i } from "../../../foundation/utilities/primitives/PrimitiveType.js";
+import { BaseCreator as a } from "../../../foundation/domainObjectsHelpers/BaseCreator.js";
+import { Plane as o, Vector3 as s } from "three";
+//#region libs/shared/reveal-components/src/domains/primitives/line/LineCreator.ts
+var c = class extends a {
+	_domainObject;
+	_undoManager;
+	constructor(e, t) {
+		super(), this._domainObject = e, this._domainObject.focusType = r.Pending, this._undoManager = t;
+	}
+	get preferIntersection() {
+		return !0;
+	}
+	get domainObject() {
+		return this._domainObject;
+	}
+	get minimumPointCount() {
+		switch (this._domainObject.primitiveType) {
+			case i.Polygon: return 3;
+			default: return 2;
+		}
+	}
+	get maximumPointCount() {
+		switch (this._domainObject.primitiveType) {
+			case i.Line: return 2;
+			default: return 2 ** 53 - 1;
+		}
+	}
+	addPointCore(i, a, o) {
+		if (a = this.transformInputPoint(i, a, o), a === void 0) return !1;
+		let s = this._domainObject;
+		if (this.lastIsPending && s.points.pop(), this.pointCount !== s.pointCount && (e(this.points, s.points), this.lastIsPending = !1), this.addRawPoint(a, o), !o && s.hasParent && this._undoManager !== void 0) {
+			let e = this._undoManager.hasUniqueId(s.uniqueId);
+			this._undoManager.addTransaction(s.createTransaction(e ? n.geometry : n.added)) && t(s)?.updateAllCommands();
+		}
+		return e(s.points, this.points), s.notify(n.geometry), this.isFinished && s.setFocus(r.Focus), !0;
+	}
+	escape() {
+		let e = this._domainObject;
+		return this.notPendingPointCount < this.minimumPointCount ? (e.remove(), !1) : (this.lastIsPending && (e.points.pop(), this.removePendingPoint(), e.notify(n.geometry)), e.setFocus(r.Focus), !0);
+	}
+	transformInputPoint(e, t, n) {
+		if (!n || this.notPendingPointCount === 1 || t !== void 0) return t;
+		let r = this.lastNotPendingPoint, i = new o().setFromNormalAndCoplanarPoint(e.direction, r), a = e.intersectPlane(i, new s());
+		if (a !== null) return a;
+	}
+};
+//#endregion
+export { c as LineCreator };