@cognite/reveal-components 1.0.0

package/dist/domains/annotations/AnnotationsView.js

@@ -0,0 +1,225 @@
+import { Changes as e } from "../../foundation/domainObjectsHelpers/Changes.js";
+import { ALL_STATUSES as t, Status as n } from "./helpers/Status.js";
+import { BoxUtils as r } from "../../foundation/utilities/primitives/BoxUtils.js";
+import { Cylinder as i } from "../../foundation/utilities/primitives/Cylinder.js";
+import { AnnotationChangedDescription as a } from "./helpers/AnnotationChangedDescription.js";
+import { VIEWER_TO_CDF_TRANSFORMATION as o } from "../../foundation/renderTarget/convertCoordinates.js";
+import { isAnyCornersVisibleByPlanes as s } from "../../foundation/utilities/geometry/isBoxVisibleByPlanes.js";
+import { CylinderUtils as c } from "../../foundation/utilities/primitives/CylinderUtils.js";
+import { GroupThreeView as l } from "../../foundation/views/GroupThreeView.js";
+import { createWireframeFromMultipleAnnotations as u } from "./helpers/createWireframeFromMultipleAnnotations.js";
+import { getClosestAnnotation as d } from "./helpers/getClosestAnnotation.js";
+import { Box3 as f, Group as p, Matrix4 as m, Mesh as h, MeshBasicMaterial as g, Vector2 as _ } from "three";
+import { CDF_TO_VIEWER_TRANSFORMATION as v } from "@cognite/reveal";
+import { LineMaterial as y } from "three/examples/jsm/lines/LineMaterial.js";
+import { Wireframe as b } from "three/examples/jsm/lines/Wireframe.js";
+//#region libs/shared/reveal-components/src/domains/annotations/AnnotationsView.ts
+var x = "focus-annotation-name", S = 100, C = class extends l {
+	contextLineMaterial;
+	approvedLineMaterial;
+	suggestedLineMaterial;
+	rejectedLineMaterial;
+	contextSelectedLineMaterial;
+	approvedSelectedLineMaterial;
+	suggestedSelectedLineMaterial;
+	rejectedSelectedLineMaterial;
+	focusAnnotationMaterial;
+	globalMatrix = new m();
+	get style() {
+		return super.style;
+	}
+	constructor() {
+		super(), this.globalMatrix = v.clone(), this.contextLineMaterial = w(), this.approvedLineMaterial = w(), this.suggestedLineMaterial = w(), this.rejectedLineMaterial = w(), this.contextSelectedLineMaterial = w(), this.approvedSelectedLineMaterial = w(), this.suggestedSelectedLineMaterial = w(), this.rejectedSelectedLineMaterial = w(), this.focusAnnotationMaterial = new g();
+	}
+	update(t) {
+		super.update(t), t.isChanged(e.renderStyle) && (this.updateRenderStyle(), this.invalidateRenderTarget()), t.isChanged(e.selected) && (this.updateSelectedAnnotation(), this.invalidateRenderTarget()), t.isChanged(e.focus) && (this.updateFocusAnnotation(), this.invalidateRenderTarget()), t.isChanged(e.clipping) && (this.removeChildren(), this.invalidateRenderTarget());
+		let n = t.getChangedDescriptionByType(a);
+		if (n !== void 0) {
+			if (n.change === e.addedPart) this.removeChildren(), this.invalidateRenderTarget();
+			else {
+				let t = n.annotation;
+				for (let r of this.getWireframes()) {
+					let i = D(r);
+					if (i === void 0 || i.isEmpty || !i.includes(t)) continue;
+					let a = n.change === e.deletedPart ? i.annotations.filter((e) => e !== t) : i.annotations;
+					this.addWireframeFromMultipleAnnotations({
+						annotations: a,
+						globalMatrix: this.globalMatrix,
+						status: i.status,
+						selected: i.selected,
+						startIndex: 0
+					}), this._group.remove(r), O(r), this.invalidateRenderTarget();
+					break;
+				}
+			}
+		}
+	}
+	get useDepthTest() {
+		return this.style.depthTest;
+	}
+	calculateBoundingBox() {
+		let e = this.domainObject.annotations, t = new f().makeEmpty(), n = this.renderTarget.getGlobalClippingPlanes();
+		if (n.length === 0) this.domainObject.expandBoundingBox(t), t.applyMatrix4(this.globalMatrix);
+		else {
+			let r = new f();
+			for (let i of e) r.makeEmpty(), i.expandBoundingBox(r), r.applyMatrix4(this.globalMatrix), s(n, r) && t.union(r);
+		}
+		return t;
+	}
+	addChildren() {
+		let { domainObject: e } = this;
+		this.updateRenderStyle();
+		let n = e.annotations;
+		if (n === void 0) return;
+		let r = this.renderTarget.getGlobalClippingPlanes(), i = new f();
+		for (let e of t) {
+			let t = n.filter((t) => t.getStatus() === e ? r.length === 0 || (i.makeEmpty(), t.expandBoundingBox(i), i.applyMatrix4(this.globalMatrix), s(r, i)) : !1);
+			for (let n = 0; n < t.length; n += S) this.addWireframeFromMultipleAnnotations({
+				annotations: t,
+				globalMatrix: this.globalMatrix,
+				status: e,
+				selected: !1,
+				startIndex: n,
+				groupSize: S
+			});
+		}
+		this.updateSelectedAnnotation(), this.updateFocusAnnotation();
+	}
+	intersectIfCloser(e, t) {
+		let { domainObject: n } = this, r = d(this.getAnnotations(), this.globalMatrix, e.raycaster.ray), i = r.getClosestGeometry();
+		if (i === void 0 || t !== void 0 && r.minDistance > t) return;
+		let { annotation: a } = i, o = a.getBoundingBox();
+		return o.applyMatrix4(this.globalMatrix), {
+			type: "customObject",
+			distanceToCamera: r.minDistance,
+			point: i.point,
+			customObject: this,
+			domainObject: n,
+			boundingBox: o,
+			userData: i
+		};
+	}
+	updateSelectedAnnotation() {
+		let e = this.domainObject.selectedAnnotation;
+		e === void 0 ? this.clearSelectedAnnotation() : this.styleAnnotation(e, !0);
+	}
+	clearSelectedAnnotation() {
+		for (let e of this.getWireframes()) this.styleWireframe(e, !1);
+	}
+	updateFocusAnnotation() {
+		let e = this.domainObject.focusAnnotation;
+		if (this.clearFocusAnnotation(), e === void 0) return;
+		let t = this.domainObject.selectedAnnotation?.selectedPrimitive, n = new p();
+		n.name = x, this.addChild(n);
+		for (let r of e.primitives) {
+			if (t !== void 0 && t === r) continue;
+			let e = r.getMatrix();
+			if (e === void 0) continue;
+			e.premultiply(this.globalMatrix);
+			let a = r instanceof i, o = T(e, this.focusAnnotationMaterial, a);
+			n.add(o);
+		}
+	}
+	clearFocusAnnotation() {
+		let e = this._group.getObjectByName(x);
+		e !== void 0 && (this._group.remove(e), O(e));
+	}
+	updateRenderStyle() {
+		let { style: e } = this;
+		for (let n of t) this.setStyle(e, n, !1), this.setStyle(e, n, !0);
+		this.focusAnnotationMaterial.color.set(e.blankColor), this.focusAnnotationMaterial.transparent = !0, this.focusAnnotationMaterial.opacity = e.blankOpacity, this.focusAnnotationMaterial.depthTest = !0;
+	}
+	styleWireframe(e, t) {
+		let n = D(e);
+		n !== void 0 && (n.selected = t, e.material = this.getLineMaterial(n.status, t));
+	}
+	styleAnnotation(e, t) {
+		let n;
+		for (let r of this.getWireframes()) {
+			let i = D(r);
+			i !== void 0 && (i.isEmpty || (i.includes(e) ? i.length === 1 ? this.styleWireframe(r, t) : n = r : this.styleWireframe(r, !1)));
+		}
+		if (n !== void 0) {
+			let r = D(n), i = r.annotations.filter((t) => t !== e);
+			this.addWireframeFromMultipleAnnotations({
+				annotations: i,
+				globalMatrix: this.globalMatrix,
+				status: r.status,
+				selected: r.selected,
+				startIndex: 0
+			});
+			let a = [e];
+			a.length > 0 && this.addWireframeFromMultipleAnnotations({
+				annotations: a,
+				globalMatrix: this.globalMatrix,
+				status: r.status,
+				selected: t,
+				startIndex: 0
+			}), this._group.remove(n), O(n);
+		}
+	}
+	*getWireframes() {
+		for (let e of E(this._group)) yield e;
+	}
+	*getAnnotations() {
+		for (let e of this.getWireframes()) {
+			let t = D(e);
+			if (t !== void 0 && !t.isEmpty) for (let e of t.annotations) yield e;
+		}
+	}
+	getLineMaterial(e, t) {
+		switch (t) {
+			case !0: switch (e) {
+				case n.Contextualized: return this.contextSelectedLineMaterial;
+				case n.Approved: return this.approvedSelectedLineMaterial;
+				case n.Suggested: return this.suggestedSelectedLineMaterial;
+				case n.Rejected: return this.rejectedSelectedLineMaterial;
+				default: return this.suggestedSelectedLineMaterial;
+			}
+			case !1: switch (e) {
+				case n.Contextualized: return this.contextLineMaterial;
+				case n.Approved: return this.approvedLineMaterial;
+				case n.Suggested: return this.suggestedLineMaterial;
+				case n.Rejected: return this.rejectedLineMaterial;
+				default: return this.suggestedLineMaterial;
+			}
+		}
+	}
+	setStyle(e, t, n) {
+		let r = this.getLineMaterial(t, n);
+		r.linewidth = n ? e.selectedLineWidth : e.lineWidth, r.depthTest = e.depthTest, r.color.set(e.getColorByStatus(t));
+	}
+	addWireframeFromMultipleAnnotations(e) {
+		let t = this.getLineMaterial(e.status, e.selected), n = u(e, t);
+		n !== void 0 && this.addChild(n);
+	}
+};
+function w() {
+	return new y({
+		resolution: new _(800, 800),
+		dashed: !1,
+		depthTest: !0,
+		dashScale: 8
+	});
+}
+function T(e, t, n) {
+	let i = n ? c.createUnitGeometry() : r.createUnitGeometry();
+	n && i.applyMatrix4(o);
+	let a = new h(i, t);
+	return a.applyMatrix4(e), a;
+}
+function* E(e) {
+	if (e !== null) {
+		for (let t of e.children) if (t instanceof b && (yield t), !(t instanceof h)) for (let e of E(t)) yield e;
+	}
+}
+function D(e) {
+	return e.userData;
+}
+function O(e) {
+	e.traverse((e) => {
+		(e instanceof b || e instanceof h) && e.geometry.dispose();
+	});
+}
+//#endregion
+export { C as AnnotationsView };

package/dist/domains/annotations/BoxGizmoDomainObject.d.ts

@@ -0,0 +1,20 @@
+import { BaseCommand } from '../../foundation/commands/BaseCommand';
+import { DomainObject } from '../../foundation/domainObjects/DomainObject';
+import { DomainObjectChange } from '../../foundation/domainObjectsHelpers/DomainObjectChange';
+import { RenderStyle } from '../../foundation/renderStyles/RenderStyle';
+import { TranslationInput } from '../../foundation/utilities/translation/TranslateInput';
+import { BoxDomainObject } from '../primitives/box/BoxDomainObject';
+import { Annotation } from './helpers/Annotation';
+export declare class BoxGizmoDomainObject extends BoxDomainObject {
+    constructor();
+    get typeName(): TranslationInput;
+    createRenderStyle(): RenderStyle | undefined;
+    clone(what?: symbol): DomainObject;
+    protected notifyCore(change: DomainObjectChange): void;
+    getPanelToolbar(): BaseCommand[];
+    get isVisibleInTree(): boolean;
+    get hasClippingInIntersection(): boolean;
+    createAnnotation(): Annotation;
+    updateThisFromAnnotation(annotation: Annotation): boolean;
+    private updateSelectedAnnotationFromThis;
+}

package/dist/domains/annotations/BoxGizmoDomainObject.js

@@ -0,0 +1,62 @@
+import { Changes as e } from "../../foundation/domainObjectsHelpers/Changes.js";
+import { CopyToClipboardCommand as t } from "../../foundation/concreteCommands/general/CopyToClipboardCommand.js";
+import { CycleLengthUnitsCommand as n } from "../../foundation/concreteCommands/units/CycleLengthUnitsCommand.js";
+import { SolidDomainObject as r } from "../primitives/common/SolidDomainObject.js";
+import { Box as i } from "../../foundation/utilities/primitives/Box.js";
+import { SolidPrimitiveRenderStyle as a } from "../primitives/common/SolidPrimitiveRenderStyle.js";
+import { BoxDomainObject as o } from "../primitives/box/BoxDomainObject.js";
+import { Annotation as s } from "./helpers/Annotation.js";
+import { AnnotationChangedDescription as c } from "./helpers/AnnotationChangedDescription.js";
+import { Color as l } from "three";
+//#region libs/shared/reveal-components/src/domains/annotations/BoxGizmoDomainObject.ts
+var u = class u extends o {
+	constructor() {
+		super(), this.setColor(l.NAMES.white);
+	}
+	get typeName() {
+		return { key: "BOX" };
+	}
+	createRenderStyle() {
+		let e = new a();
+		return e.showLabel = !1, e.solidOpacity = .3333, e;
+	}
+	clone(e) {
+		let t = new u();
+		return t.copyFrom(this, e), t;
+	}
+	notifyCore(t) {
+		super.notifyCore(t);
+		let n = t.getChangedDescription(e.geometry);
+		n !== void 0 && !n.isChanged(r.GizmoOnly) ? this.updateSelectedAnnotationFromThis(!1) : t.isChanged(e.dragging) && this.updateSelectedAnnotationFromThis(!0);
+	}
+	getPanelToolbar() {
+		return [new t(), new n()];
+	}
+	get isVisibleInTree() {
+		return !1;
+	}
+	get hasClippingInIntersection() {
+		return !1;
+	}
+	createAnnotation() {
+		let e = new i();
+		return e.copy(this.box), s.create(e);
+	}
+	updateThisFromAnnotation(e) {
+		let t = e.selectedPrimitive;
+		return t instanceof i && (this.box.copy(t), !0);
+	}
+	updateSelectedAnnotationFromThis(t) {
+		let n = this.parent;
+		if (n === void 0) return !1;
+		let r = n.selectedAnnotation;
+		if (r === void 0) return !1;
+		let a = r.selectedPrimitive;
+		if (!(a instanceof i)) return !1;
+		a.copy(this.box);
+		let o = t ? e.dragging : e.changedPart, s = new c(o, r);
+		return n.notify(s), !0;
+	}
+};
+//#endregion
+export { u as BoxGizmoDomainObject };

package/dist/domains/annotations/CylinderGizmoDomainObject.d.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../../foundation/commands/BaseCommand';
+import { DomainObject } from '../../foundation/domainObjects/DomainObject';
+import { DomainObjectChange } from '../../foundation/domainObjectsHelpers/DomainObjectChange';
+import { RenderStyle } from '../../foundation/renderStyles/RenderStyle';
+import { PrimitiveType } from '../../foundation/utilities/primitives/PrimitiveType';
+import { TranslationInput } from '../../foundation/utilities/translation/TranslateInput';
+import { CylinderDomainObject } from '../primitives/cylinder/CylinderDomainObject';
+import { Annotation } from './helpers/Annotation';
+export declare class CylinderGizmoDomainObject extends CylinderDomainObject {
+    constructor(primitiveType?: PrimitiveType);
+    get typeName(): TranslationInput;
+    createRenderStyle(): RenderStyle | undefined;
+    clone(what?: symbol): DomainObject;
+    protected notifyCore(change: DomainObjectChange): void;
+    getPanelToolbar(): BaseCommand[];
+    get isVisibleInTree(): boolean;
+    get hasClippingInIntersection(): boolean;
+    createAnnotation(): Annotation;
+    updateThisFromAnnotation(annotation: Annotation): boolean;
+    private updateSelectedAnnotationFromThis;
+}

package/dist/domains/annotations/CylinderGizmoDomainObject.js

@@ -0,0 +1,63 @@
+import { Changes as e } from "../../foundation/domainObjectsHelpers/Changes.js";
+import { CopyToClipboardCommand as t } from "../../foundation/concreteCommands/general/CopyToClipboardCommand.js";
+import { CycleLengthUnitsCommand as n } from "../../foundation/concreteCommands/units/CycleLengthUnitsCommand.js";
+import { PrimitiveType as r } from "../../foundation/utilities/primitives/PrimitiveType.js";
+import { SolidDomainObject as i } from "../primitives/common/SolidDomainObject.js";
+import { SolidPrimitiveRenderStyle as a } from "../primitives/common/SolidPrimitiveRenderStyle.js";
+import { Cylinder as o } from "../../foundation/utilities/primitives/Cylinder.js";
+import { Annotation as s } from "./helpers/Annotation.js";
+import { AnnotationChangedDescription as c } from "./helpers/AnnotationChangedDescription.js";
+import { CylinderDomainObject as l } from "../primitives/cylinder/CylinderDomainObject.js";
+import { Color as u } from "three";
+//#region libs/shared/reveal-components/src/domains/annotations/CylinderGizmoDomainObject.ts
+var d = class d extends l {
+	constructor(e = r.Cylinder) {
+		super(e), this.setColor(u.NAMES.white);
+	}
+	get typeName() {
+		return { key: "CYLINDER" };
+	}
+	createRenderStyle() {
+		let e = new a();
+		return e.showLabel = !1, e.solidOpacity = .3333, e;
+	}
+	clone(e) {
+		let t = new d();
+		return t.copyFrom(this, e), t;
+	}
+	notifyCore(t) {
+		super.notifyCore(t);
+		let n = t.getChangedDescription(e.geometry);
+		n !== void 0 && !n.isChanged(i.GizmoOnly) ? this.updateSelectedAnnotationFromThis(!1) : t.isChanged(e.dragging) && this.updateSelectedAnnotationFromThis(!0);
+	}
+	getPanelToolbar() {
+		return [new t(), new n()];
+	}
+	get isVisibleInTree() {
+		return !1;
+	}
+	get hasClippingInIntersection() {
+		return !1;
+	}
+	createAnnotation() {
+		let e = new o();
+		return e.copy(this.cylinder), s.create(e);
+	}
+	updateThisFromAnnotation(e) {
+		let t = e.selectedPrimitive;
+		return t instanceof o && (this.cylinder.copy(t), !0);
+	}
+	updateSelectedAnnotationFromThis(t) {
+		let n = this.parent;
+		if (n === void 0) return !1;
+		let r = n.selectedAnnotation;
+		if (r === void 0) return !1;
+		let i = r.selectedPrimitive;
+		if (!(i instanceof o)) return !1;
+		i.copy(this.cylinder);
+		let a = t ? e.dragging : e.changedPart, s = new c(a, r);
+		return n.notify(s), !0;
+	}
+};
+//#endregion
+export { d as CylinderGizmoDomainObject };

package/dist/domains/annotations/commands/AnnotationsAlignCommand.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../../foundation/commands/BaseCommand';
+import { RenderTargetCommand } from '../../../foundation/commands/RenderTargetCommand';
+import { TranslationInput } from '../../../foundation/utilities/translation/TranslateInput';
+import { IconName } from '../../../foundation/utilities/types';
+export declare class AlignSelectedAnnotationCommand extends RenderTargetCommand {
+    private readonly _horizontal;
+    constructor(horizontal: boolean);
+    get tooltip(): TranslationInput;
+    get icon(): IconName;
+    get isEnabled(): boolean;
+    equals(other: BaseCommand): boolean;
+    protected invokeCore(): boolean;
+    private getAnnotationsDomainObject;
+}

package/dist/domains/annotations/commands/AnnotationsAlignCommand.js

@@ -0,0 +1,44 @@
+import { RenderTargetCommand as e } from "../../../foundation/commands/RenderTargetCommand.js";
+import { Changes as t } from "../../../foundation/domainObjectsHelpers/Changes.js";
+import { DomainObjectChange as n } from "../../../foundation/domainObjectsHelpers/DomainObjectChange.js";
+import { SolidDomainObject as r } from "../../primitives/common/SolidDomainObject.js";
+import { AnnotationChangedDescription as i } from "../helpers/AnnotationChangedDescription.js";
+import { AnnotationsDomainObject as a } from "../AnnotationsDomainObject.js";
+//#region libs/shared/reveal-components/src/domains/annotations/commands/AnnotationsAlignCommand.ts
+var o = class o extends e {
+	_horizontal;
+	constructor(e) {
+		super(), this._horizontal = e;
+	}
+	get tooltip() {
+		return this._horizontal ? { untranslated: "Align selected annotation horizontally" } : { untranslated: "Align selected annotation vertically" };
+	}
+	get icon() {
+		return this._horizontal ? "BorderHorizontal" : "BorderVertical";
+	}
+	get isEnabled() {
+		let e = this.getAnnotationsDomainObject();
+		return e !== void 0 && e.selectedAnnotation !== void 0 && e.selectedAnnotation.selectedPrimitive !== void 0;
+	}
+	equals(e) {
+		return e instanceof o && this._horizontal === e._horizontal;
+	}
+	invokeCore() {
+		let e = this.getAnnotationsDomainObject();
+		if (e === void 0) return !1;
+		let a = e.selectedAnnotation;
+		if (a === void 0 || !a.align(this._horizontal)) return !1;
+		let o = new i(t.changedPart, a);
+		e.notify(o);
+		let s = e.getGizmo();
+		if (s === void 0) return !0;
+		s.updateThisFromAnnotation(a);
+		let c = new n(t.geometry, r.GizmoOnly);
+		return s.notify(c), !0;
+	}
+	getAnnotationsDomainObject() {
+		return this.root.getSelectedDescendantByType(a);
+	}
+};
+//#endregion
+export { o as AlignSelectedAnnotationCommand };

package/dist/domains/annotations/commands/AnnotationsCreateMockCommand.d.ts

@@ -0,0 +1,11 @@
+import { InstanceCommand } from '../../../foundation/commands/InstanceCommand';
+import { DomainObject } from '../../../foundation/domainObjects/DomainObject';
+import { TranslationInput } from '../../../foundation/utilities/translation/TranslateInput';
+import { IconName } from '../../../foundation/utilities/types';
+export declare class AnnotationsCreateMockCommand extends InstanceCommand {
+    get icon(): IconName;
+    get tooltip(): TranslationInput;
+    get isEnabled(): boolean;
+    protected isInstance(domainObject: DomainObject): boolean;
+    protected invokeCore(): boolean;
+}

package/dist/domains/annotations/commands/AnnotationsCreateMockCommand.js

@@ -0,0 +1,60 @@
+import { Changes as e } from "../../../foundation/domainObjectsHelpers/Changes.js";
+import { getRandomInt as t } from "../../../foundation/utilities/extensions/mathUtils.js";
+import { Box as n } from "../../../foundation/utilities/primitives/Box.js";
+import { Cylinder as r } from "../../../foundation/utilities/primitives/Cylinder.js";
+import { Annotation as i } from "../helpers/Annotation.js";
+import { AnnotationChangedDescription as a } from "../helpers/AnnotationChangedDescription.js";
+import { AnnotationsDomainObject as o } from "../AnnotationsDomainObject.js";
+import { InstanceCommand as s } from "../../../foundation/commands/InstanceCommand.js";
+import { Matrix4 as c, Vector3 as l } from "three";
+import "three/src/math/MathUtils.js";
+//#region libs/shared/reveal-components/src/domains/annotations/commands/AnnotationsCreateMockCommand.ts
+var u = class extends s {
+	get icon() {
+		return "Bug";
+	}
+	get tooltip() {
+		return { untranslated: "Create a mock annotation" };
+	}
+	get isEnabled() {
+		return !this.anyInstances;
+	}
+	isInstance(e) {
+		return e instanceof o;
+	}
+	invokeCore() {
+		let { renderTarget: e, root: t } = this, n = this.getFirstInstance();
+		return n === void 0 && (n = new o(), n.applyPendingWhenCreated = !0, n.annotations = p(), n.setSelected(!0), t.addChild(n), n.setVisible(!0, e), n.views.addEventListener(m), !0);
+	}
+};
+function d(e) {
+	let t = new n();
+	return t.setMatrix(e), t;
+}
+function f(e, t, n) {
+	let i = new r();
+	return i.radius = n, i.centerA.copy(e), i.centerB.copy(t), i;
+}
+function p() {
+	let e = [], n = .5;
+	for (let r = 0; r < 6; r++) {
+		let a = 4 * r + 2, o = 4 * r, s = new l(a, o, 0), u = s.clone();
+		u.x += 4;
+		let p = f(s, u, n);
+		s.x += 4, u.x = s.x + 2;
+		let m = s.clone().add(u).multiplyScalar(.5), h = new c().makeTranslation(m);
+		h.multiply(new c().makeScale(1, 2, 1));
+		let g = d(h);
+		s.x += 2, u.x = s.x + 6;
+		let _ = f(s, u, 2 * n), v = new i();
+		v.id = t(), v.label = "test", v.primitives.push(p, g, _), r % 3 == 0 ? v.status = "rejected" : r % 3 == 1 ? v.status = "suggested" : (v.status = "approved", v.setAssetRefId(t())), e.push(v);
+	}
+	return e;
+}
+function m(t, n) {
+	if (!(t instanceof o)) return;
+	let r = n.getChangedDescriptionByType(a);
+	r instanceof a && (r.annotation, r.annotation.selectedPrimitive, r.change, e.changedPart, r.change === e.dragging || r.change === e.deletedPart || (r.change, e.addedPart)), n.isChanged(e.newPending), n.isChanged(e.selected) && t.selectedAnnotation, n.isChanged(e.focus) && t.focusAnnotation;
+}
+//#endregion
+export { u as AnnotationsCreateMockCommand };

package/dist/domains/annotations/commands/AnnotationsCreateTool.d.ts

@@ -0,0 +1,25 @@
+import { NavigationTool } from '../../../foundation/concreteCommands/navigation/NavigationTool';
+import { PrimitiveType } from '../../../foundation/utilities/primitives/PrimitiveType';
+import { TranslationInput } from '../../../foundation/utilities/translation/TranslateInput';
+import { IconName } from '../../../foundation/utilities/types';
+export declare const ANNOTATION_RADIUS_FACTOR = 0.2;
+export declare class AnnotationsCreateTool extends NavigationTool {
+    private _creator;
+    primitiveType: PrimitiveType;
+    constructor();
+    get icon(): IconName;
+    get tooltip(): TranslationInput;
+    onActivate(): void;
+    onDeactivate(): void;
+    clearDragging(): void;
+    onEscapeKey(): boolean;
+    onHoverByDebounce(event: PointerEvent): Promise<void>;
+    onClick(event: PointerEvent): Promise<void>;
+    private createCreator;
+    escape(): boolean;
+    private getSelectedAnnotationsDomainObject;
+    private getSelectedAnnotationsDomainObjectByForce;
+    private setSelectTool;
+    private endCreatorIfFinished;
+    private deselectedAnnotation;
+}