@cognite/reveal-components 1.0.0

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

@@ -0,0 +1,141 @@
+import { Changes as e } from "../../../foundation/domainObjectsHelpers/Changes.js";
+import { PrimitiveType as t } from "../../../foundation/utilities/primitives/PrimitiveType.js";
+import { BoxGizmoDomainObject as n } from "../BoxGizmoDomainObject.js";
+import { CylinderGizmoDomainObject as r } from "../CylinderGizmoDomainObject.js";
+import { AnnotationsDomainObject as i } from "../AnnotationsDomainObject.js";
+import { NavigationTool as a } from "../../../foundation/concreteCommands/navigation/NavigationTool.js";
+import { isImage360ClusterIntersection as o } from "../../../foundation/utilities/misc/typeGuards.js";
+import { BoxCreator as s } from "../../primitives/box/BoxCreator.js";
+import { CylinderCreator as c } from "../../primitives/cylinder/CylinderCreator.js";
+import { AnnotationsSelectTool as l } from "./AnnotationsSelectTool.js";
+//#region libs/shared/reveal-components/src/domains/annotations/commands/AnnotationsCreateTool.ts
+var u = class extends a {
+	_creator = void 0;
+	primitiveType;
+	constructor() {
+		super(), this.primitiveType = t.Box;
+	}
+	get icon() {
+		return "Shapes";
+	}
+	get tooltip() {
+		return { untranslated: "Create new annotation. Select type of annotation in the toolbar below." };
+	}
+	onActivate() {
+		super.onActivate();
+		let e = this.getSelectedAnnotationsDomainObject();
+		e !== void 0 && e.setVisible(!0, this.renderTarget);
+	}
+	onDeactivate() {
+		super.onDeactivate(), this.escape();
+	}
+	clearDragging() {
+		super.clearDragging(), this._creator = void 0;
+	}
+	onEscapeKey() {
+		return this.escape();
+	}
+	async onHoverByDebounce(e) {
+		let { _creator: t } = this;
+		if (t !== void 0) {
+			let n = this.getRay(e);
+			if (t.addPoint(n, void 0, !0)) {
+				this.setDefaultCursor();
+				return;
+			}
+			let r = await this.getIntersection(e);
+			if (r === void 0 || o(r)) {
+				if (t !== void 0 && t.preferIntersection && t.addPoint(n, void 0, !0)) {
+					this.setDefaultCursor();
+					return;
+				}
+				this.renderTarget.setNavigateCursor();
+				return;
+			}
+			if (l.getIntersectedAnnotationsDomainObject(r) !== void 0) {
+				this.renderTarget.setNavigateCursor();
+				return;
+			}
+			if (t.addPoint(n, r.point, !0)) {
+				this.setDefaultCursor();
+				return;
+			}
+			this.renderTarget.setNavigateCursor();
+		} else await this.getIntersection(e) === void 0 ? this.renderTarget.setNavigateCursor() : this.renderTarget.setCrosshairCursor();
+	}
+	async onClick(t) {
+		let { renderTarget: n } = this, r = this._creator;
+		if (r !== void 0) {
+			let e = this.getRay(t);
+			if (r.addPoint(e)) {
+				this.endCreatorIfFinished(r);
+				return;
+			}
+		}
+		let i = await this.getIntersection(t);
+		if (!(i === void 0 || o(i))) {
+			if (r !== void 0) {
+				let e = this.getRay(t);
+				r.addPoint(e, i.point) && this.endCreatorIfFinished(r);
+				return;
+			}
+			if (r === void 0) {
+				if (this.deselectedAnnotation(), r = this._creator = this.createCreator(), r === void 0) {
+					await super.onClick(t);
+					return;
+				}
+				let a = this.getRay(t);
+				if (r.addPoint(a, i.point)) {
+					let t = r.domainObject;
+					t.setSelected(!0), t.setVisible(!0, n), t.notify(e.geometry);
+				} else {
+					this._creator = void 0;
+					return;
+				}
+				this.endCreatorIfFinished(r);
+				return;
+			}
+			this.renderTarget.cursor = "move";
+		}
+	}
+	createCreator() {
+		let e = this.getSelectedAnnotationsDomainObjectByForce().getOrCreateGizmoForPending(this.primitiveType);
+		switch (this.primitiveType) {
+			case t.Box: return e instanceof n ? new s(e) : void 0;
+			case t.HorizontalCylinder:
+			case t.VerticalCylinder: return e instanceof r ? new c(e, this.primitiveType) : void 0;
+			default: return;
+		}
+	}
+	escape() {
+		return this._creator !== void 0 && (this._creator.escape() ? (this.endCreatorIfFinished(this._creator, !0), this.setSelectTool(), this.deselectedAnnotation()) : this._creator = void 0, !0);
+	}
+	getSelectedAnnotationsDomainObject() {
+		return this.root.getSelectedDescendantByType(i);
+	}
+	getSelectedAnnotationsDomainObjectByForce() {
+		let e = this.getSelectedAnnotationsDomainObject();
+		if (e !== void 0) return e;
+		let t = new i();
+		return t.applyPendingWhenCreated = !0, this.root.addChild(t), t.setSelected(!0), t.setVisible(!0), t;
+	}
+	setSelectTool() {
+		this.renderTarget.commandsController.setActiveToolByType(l) && this._renderTarget?.updateAllCommands();
+	}
+	endCreatorIfFinished(t, i = !1) {
+		if (!t.isFinished && !i) return;
+		this._creator = void 0;
+		let a = this.getSelectedAnnotationsDomainObject();
+		if (a === void 0) return;
+		let o = t.domainObject, s;
+		if (o instanceof n || o instanceof r) s = o.createAnnotation();
+		else return;
+		a.pendingAnnotation = s, a.applyPendingWhenCreated ? a.applyPendingAnnotation() : a.notify(e.newPending), this.setSelectTool();
+	}
+	deselectedAnnotation() {
+		let e = this.getSelectedAnnotationsDomainObject();
+		e !== void 0 && e.setSelectedAnnotation(void 0);
+	}
+};
+//#endregion
+export { u as AnnotationsCreateTool };

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

@@ -0,0 +1,11 @@
+import { RenderTargetCommand } from '../../../foundation/commands/RenderTargetCommand';
+import { TranslationInput } from '../../../foundation/utilities/translation/TranslateInput';
+import { IconName, ButtonType } from '../../../foundation/utilities/types';
+export declare class AnnotationsDeleteCommand extends RenderTargetCommand {
+    get tooltip(): TranslationInput;
+    get icon(): IconName;
+    get buttonType(): ButtonType;
+    get isEnabled(): boolean;
+    protected invokeCore(): boolean;
+    private getAnnotationsDomainObject;
+}

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

@@ -0,0 +1,27 @@
+import { RenderTargetCommand as e } from "../../../foundation/commands/RenderTargetCommand.js";
+import { AnnotationsDomainObject as t } from "../AnnotationsDomainObject.js";
+//#region libs/shared/reveal-components/src/domains/annotations/commands/AnnotationsDeleteCommand.ts
+var n = class extends e {
+	get tooltip() {
+		return { untranslated: "Delete selected annotations" };
+	}
+	get icon() {
+		return "Delete";
+	}
+	get buttonType() {
+		return "ghost-destructive";
+	}
+	get isEnabled() {
+		let e = this.getAnnotationsDomainObject();
+		return e !== void 0 && e.selectedAnnotation !== void 0 && e.selectedAnnotation.selectedPrimitive !== void 0;
+	}
+	invokeCore() {
+		let e = this.getAnnotationsDomainObject();
+		return e !== void 0 && e.removeSelectedAnnotation();
+	}
+	getAnnotationsDomainObject() {
+		return this.root.getSelectedDescendantByType(t);
+	}
+};
+//#endregion
+export { n as AnnotationsDeleteCommand };

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

@@ -0,0 +1,26 @@
+import { AnyIntersection } from '@cognite/reveal';
+import { BaseEditTool } from '../../../foundation/commands/BaseEditTool';
+import { VisualDomainObject } from '../../../foundation/domainObjects/VisualDomainObject';
+import { BaseDragger } from '../../../foundation/domainObjectsHelpers/BaseDragger';
+import { TranslationInput } from '../../../foundation/utilities/translation/TranslateInput';
+import { IconName } from '../../../foundation/utilities/types';
+import { AnnotationsDomainObject } from '../AnnotationsDomainObject';
+export declare const ANNOTATION_RADIUS_FACTOR = 0.2;
+export declare class AnnotationsSelectTool extends BaseEditTool {
+    constructor();
+    get icon(): IconName;
+    get tooltip(): TranslationInput;
+    onActivate(): void;
+    onDeactivate(): void;
+    onDeleteKey(): void;
+    onEscapeKey(): boolean;
+    onHoverByDebounce(event: PointerEvent): Promise<void>;
+    onClick(event: PointerEvent): Promise<void>;
+    protected createDragger(event: PointerEvent): Promise<BaseDragger | undefined>;
+    protected deselectAll(_except?: VisualDomainObject | undefined): void;
+    protected canBeSelected(domainObject: VisualDomainObject): boolean;
+    private getSelectedAnnotationsDomainObject;
+    private unfocusAll;
+    private deselectedAnnotation;
+    static getIntersectedAnnotationsDomainObject(intersection: AnyIntersection | undefined): AnnotationsDomainObject | undefined;
+}

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

@@ -0,0 +1,94 @@
+import { FocusType as e } from "../../../foundation/domainObjectsHelpers/FocusType.js";
+import { SolidDomainObject as t } from "../../primitives/common/SolidDomainObject.js";
+import { AnnotationsDomainObject as n } from "../AnnotationsDomainObject.js";
+import { VIEWER_TO_CDF_TRANSFORMATION as r, convertFromViewerCoordinates as i } from "../../../foundation/renderTarget/convertCoordinates.js";
+import { isDomainObjectIntersection as a } from "../../../foundation/domainObjectsHelpers/DomainObjectIntersection.js";
+import { BaseEditTool as o } from "../../../foundation/commands/BaseEditTool.js";
+import { isAnnotationsOrGizmo as s, isGizmo as c } from "./isGizmo.js";
+//#region libs/shared/reveal-components/src/domains/annotations/commands/AnnotationsSelectTool.ts
+var l = class t extends o {
+	constructor() {
+		super();
+	}
+	get icon() {
+		return "Cursor";
+	}
+	get tooltip() {
+		return { untranslated: "Edit annotations" };
+	}
+	onActivate() {
+		super.onActivate();
+		let e = this.getSelectedAnnotationsDomainObject();
+		e !== void 0 && e.setVisible(!0, this.renderTarget);
+	}
+	onDeactivate() {
+		super.onDeactivate();
+		for (let e of this.root.getDescendantsByType(n)) e.removeGizmo();
+	}
+	onDeleteKey() {
+		let e = this.getSelectedAnnotationsDomainObject();
+		e !== void 0 && e.removeSelectedAnnotation();
+	}
+	onEscapeKey() {
+		return this.deselectedAnnotation();
+	}
+	async onHoverByDebounce(n) {
+		let r = this.getSpecificIntersection(n, s), i = t.getIntersectedAnnotationsDomainObject(r), o = u(r), c = d(r);
+		if (i !== void 0 && o !== void 0) this.renderTarget.setDefaultCursor(), o.annotation === i.selectedAnnotation ? i.setFocusAnnotation(e.None) : i.setFocusAnnotation(e.Focus, o.annotation);
+		else if (c === void 0) this.renderTarget.setNavigateCursor(), this.unfocusAll();
+		else if (c !== void 0 && a(r)) {
+			this.unfocusAll();
+			let e = r.userData;
+			c.setFocus(e.focusType, e.face), this.renderTarget.cursor = c.getEditToolCursor(this.renderTarget, r.point);
+		}
+	}
+	async onClick(e) {
+		let n = await this.getIntersection(e), r = t.getIntersectedAnnotationsDomainObject(n), i = u(n), a = d(n);
+		if (r !== void 0 && i !== void 0) {
+			r.setSelectedAnnotation(i.annotation, i.primitiveIndex);
+			return;
+		}
+		r === void 0 ? a === void 0 && this.deselectedAnnotation() : r.setSelectedAnnotation(void 0), await super.onClick(e);
+	}
+	async createDragger(e) {
+		let t = await this.getIntersection(e, c);
+		if (t === void 0 || !a(t)) return;
+		let n = t.domainObject;
+		if (!c(n)) return;
+		let o = i(t.point), s = this.getRay(e);
+		return s.applyMatrix4(r), n.createDragger({
+			intersection: t,
+			point: o,
+			ray: s
+		});
+	}
+	deselectAll(e) {}
+	canBeSelected(e) {
+		return e instanceof n;
+	}
+	getSelectedAnnotationsDomainObject() {
+		return this.root.getSelectedDescendantByType(n);
+	}
+	unfocusAll(t) {
+		for (let r of this.getSelectable()) (t === void 0 || r !== t) && r instanceof n && r.setFocusAnnotation(e.None);
+	}
+	deselectedAnnotation() {
+		let e = this.getSelectedAnnotationsDomainObject();
+		return e !== void 0 && (e.setSelectedAnnotation(void 0), !0);
+	}
+	static getIntersectedAnnotationsDomainObject(e) {
+		if (e === void 0 || !a(e)) return;
+		let { domainObject: t } = e;
+		if (t instanceof n) return t;
+	}
+};
+function u(e) {
+	if (e !== void 0 && a(e)) return e.userData;
+}
+function d(e) {
+	if (e === void 0 || !a(e)) return;
+	let { domainObject: n } = e;
+	if (c(n) && n instanceof t) return n;
+}
+//#endregion
+export { l as AnnotationsSelectTool };

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

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../../foundation/commands/BaseCommand';
+import { RenderTargetCommand } from '../../../foundation/commands/RenderTargetCommand';
+import { PrimitiveType } from '../../../foundation/utilities/primitives/PrimitiveType';
+import { TranslationInput } from '../../../foundation/utilities/translation/TranslateInput';
+import { IconName } from '../../../foundation/utilities/types';
+export declare class AnnotationsSetCreateTypeCommand extends RenderTargetCommand {
+    private readonly _primitiveType;
+    constructor(primitiveType: PrimitiveType);
+    get icon(): IconName;
+    get tooltip(): TranslationInput;
+    get isEnabled(): boolean;
+    get isChecked(): boolean;
+    protected invokeCore(): boolean;
+    equals(other: BaseCommand): boolean;
+    private get tool();
+}

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

@@ -0,0 +1,44 @@
+import { RenderTargetCommand as e } from "../../../foundation/commands/RenderTargetCommand.js";
+import { PrimitiveType as t } from "../../../foundation/utilities/primitives/PrimitiveType.js";
+import { getIconByPrimitiveType as n } from "../../../foundation/utilities/primitives/getIconByPrimitiveType.js";
+import { AnnotationsCreateTool as r } from "./AnnotationsCreateTool.js";
+//#region libs/shared/reveal-components/src/domains/annotations/commands/AnnotationsSetCreateTypeCommand.ts
+var i = class i extends e {
+	_primitiveType;
+	constructor(e) {
+		super(), this._primitiveType = e;
+	}
+	get icon() {
+		return n(this._primitiveType);
+	}
+	get tooltip() {
+		return a(this._primitiveType);
+	}
+	get isEnabled() {
+		return this.tool !== void 0;
+	}
+	get isChecked() {
+		let { tool: e } = this;
+		return e !== void 0 && e.primitiveType === this._primitiveType;
+	}
+	invokeCore() {
+		let { tool: e } = this;
+		return e !== void 0 && (e.escape(), e.clearDragging(), e.primitiveType = this.isChecked ? t.None : this._primitiveType, !0);
+	}
+	equals(e) {
+		return e instanceof i && this._primitiveType === e._primitiveType;
+	}
+	get tool() {
+		return this.getActiveTool(r);
+	}
+};
+function a(e) {
+	switch (e) {
+		case t.Box: return { untranslated: "Create a new box annotation" };
+		case t.HorizontalCylinder: return { untranslated: "Create a new horizontal cylinder annotation. Click two times to get the center endpoints, the third defines the radius." };
+		case t.VerticalCylinder: return { untranslated: "Create a new vertical cylinder annotation. Click two times to get the center endpoints, the third defines the radius." };
+		default: throw Error("Unknown PrimitiveType");
+	}
+}
+//#endregion
+export { i as AnnotationsSetCreateTypeCommand };

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

@@ -0,0 +1,7 @@
+import { ShowAllDomainObjectsCommand } from '../../../foundation/commands/ShowAllDomainObjectsCommand';
+import { DomainObject } from '../../../foundation/domainObjects/DomainObject';
+import { TranslationInput } from '../../../foundation/utilities/translation/TranslateInput';
+export declare class AnnotationsShowCommand extends ShowAllDomainObjectsCommand {
+    get tooltip(): TranslationInput;
+    protected isInstance(domainObject: DomainObject): boolean;
+}

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

@@ -0,0 +1,13 @@
+import { isAnnotationsOrGizmo as e } from "./isGizmo.js";
+import { ShowAllDomainObjectsCommand as t } from "../../../foundation/commands/ShowAllDomainObjectsCommand.js";
+//#region libs/shared/reveal-components/src/domains/annotations/commands/AnnotationsShowCommand.ts
+var n = class extends t {
+	get tooltip() {
+		return { untranslated: "Show or hide annotations." };
+	}
+	isInstance(t) {
+		return e(t);
+	}
+};
+//#endregion
+export { n as AnnotationsShowCommand };

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

@@ -0,0 +1,7 @@
+import { ShowDomainObjectsOnTopCommand } from '../../../foundation/commands/ShowDomainObjectsOnTopCommand';
+import { DomainObject } from '../../../foundation/domainObjects/DomainObject';
+import { TranslationInput } from '../../../foundation/utilities/translation/TranslateInput';
+export declare class AnnotationsShowOnTopCommand extends ShowDomainObjectsOnTopCommand {
+    get tooltip(): TranslationInput;
+    protected isInstance(domainObject: DomainObject): boolean;
+}

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

@@ -0,0 +1,13 @@
+import { isAnnotationsOrGizmo as e } from "./isGizmo.js";
+import { ShowDomainObjectsOnTopCommand as t } from "../../../foundation/commands/ShowDomainObjectsOnTopCommand.js";
+//#region libs/shared/reveal-components/src/domains/annotations/commands/AnnotationsShowOnTopCommand.ts
+var n = class extends t {
+	get tooltip() {
+		return { untranslated: "Show all annotations on top." };
+	}
+	isInstance(t) {
+		return e(t);
+	}
+};
+//#endregion
+export { n as AnnotationsShowOnTopCommand };

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

@@ -0,0 +1,3 @@
+import { DomainObject } from '../../../foundation/domainObjects/DomainObject';
+export declare function isAnnotationsOrGizmo(domainObject: DomainObject): boolean;
+export declare function isGizmo(domainObject: DomainObject): boolean;

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

@@ -0,0 +1,12 @@
+import { BoxGizmoDomainObject as e } from "../BoxGizmoDomainObject.js";
+import { CylinderGizmoDomainObject as t } from "../CylinderGizmoDomainObject.js";
+import { AnnotationsDomainObject as n } from "../AnnotationsDomainObject.js";
+//#region libs/shared/reveal-components/src/domains/annotations/commands/isGizmo.ts
+function r(e) {
+	return e instanceof n || i(e);
+}
+function i(n) {
+	return n instanceof e || n instanceof t;
+}
+//#endregion
+export { r as isAnnotationsOrGizmo, i as isGizmo };

package/dist/domains/annotations/helpers/Annotation.d.ts

@@ -0,0 +1,47 @@
+import { Box3 } from 'three';
+import { AnnotationStatus } from '@cognite/sdk';
+import { Primitive } from '../../../foundation/utilities/primitives/Primitive';
+import { PrimitiveType } from '../../../foundation/utilities/primitives/PrimitiveType';
+import { Status } from './Status';
+declare abstract class AssetId {
+}
+export declare class AssetCentricAssetId extends AssetId {
+    id?: number;
+    externalId?: string;
+    constructor(id?: number, externalId?: string);
+}
+export declare class Annotation {
+    id: number;
+    modelId: number;
+    assetId: AssetId | undefined;
+    status: AnnotationStatus;
+    primitives: Primitive[];
+    confidence: number | undefined;
+    label: string | undefined;
+    selectedIndex: number | undefined;
+    get isEmpty(): boolean;
+    get isSingle(): boolean;
+    get hasAssetRef(): boolean;
+    get resultingCdfStatus(): AnnotationStatus;
+    get firstPrimitive(): Primitive | undefined;
+    get selectedPrimitive(): Primitive | undefined;
+    get firstLabel(): string | undefined;
+    get firstConfidence(): number | undefined;
+    get primitiveType(): PrimitiveType;
+    equalId(other: Annotation): boolean;
+    getAssetRefId(): number | undefined;
+    setAssetRefId(value: number): void;
+    getAssetRefExternalId(): string | undefined;
+    setAssetRefExternalId(value: string): void;
+    getBoundingBox(): Box3;
+    getStatus(): Status;
+    setSelectedPrimitive(primitive: Primitive): void;
+    removeSelectedPrimitive(): boolean;
+    expandBoundingBox(boundingBox: Box3): void;
+    remap(annotations: Annotation[]): undefined | Annotation;
+    align(horizontal: boolean): boolean;
+    static create(primitive: Primitive): Annotation;
+    static areEqualIncludeSelected(annotationA: Annotation | undefined, annotationB: Annotation | undefined, selectedIndexB: number | undefined): boolean;
+    static areEqual(annotationA: Annotation | undefined, annotationB: Annotation | undefined): boolean;
+}
+export {};

package/dist/domains/annotations/helpers/Annotation.js

@@ -0,0 +1,113 @@
+import { remove as e } from "../../../foundation/utilities/extensions/arrayUtils.js";
+import { PrimitiveType as t } from "../../../foundation/utilities/primitives/PrimitiveType.js";
+import { Status as n } from "./Status.js";
+import { Box as r } from "../../../foundation/utilities/primitives/Box.js";
+import { Cylinder as i } from "../../../foundation/utilities/primitives/Cylinder.js";
+import { Box3 as a } from "three";
+//#region libs/shared/reveal-components/src/domains/annotations/helpers/Annotation.ts
+var o = class {}, s = class extends o {
+	id;
+	externalId;
+	constructor(e, t) {
+		super(), this.id = e, this.externalId = t;
+	}
+}, c = class o {
+	id = 0;
+	modelId = 0;
+	assetId = void 0;
+	status = "suggested";
+	primitives = [];
+	confidence = void 0;
+	label = void 0;
+	selectedIndex = void 0;
+	get isEmpty() {
+		return this.primitives.length === 0;
+	}
+	get isSingle() {
+		return this.primitives.length === 1;
+	}
+	get hasAssetRef() {
+		return this.assetId !== void 0;
+	}
+	get resultingCdfStatus() {
+		return this.hasAssetRef ? "approved" : this.status;
+	}
+	get firstPrimitive() {
+		return this.isEmpty ? void 0 : this.primitives[0];
+	}
+	get selectedPrimitive() {
+		let e = this.selectedIndex;
+		if (!(e === void 0 || e < 0 || e >= this.primitives.length)) return this.primitives[e];
+	}
+	get firstLabel() {
+		return this.isEmpty ? void 0 : this.primitives[0].label;
+	}
+	get firstConfidence() {
+		return this.isEmpty ? void 0 : this.primitives[0].confidence;
+	}
+	get primitiveType() {
+		return this.selectedPrimitive?.primitiveType ?? t.None;
+	}
+	equalId(e) {
+		return this.id === e.id;
+	}
+	getAssetRefId() {
+		if (this.assetId instanceof s) return this.assetId.id;
+	}
+	setAssetRefId(e) {
+		if (this.assetId instanceof s) {
+			this.assetId.id = e;
+			return;
+		}
+		this.assetId = new s(e);
+	}
+	getAssetRefExternalId() {
+		if (this.assetId instanceof s) return this.assetId.externalId;
+	}
+	setAssetRefExternalId(e) {
+		this.assetId instanceof s && (this.assetId.externalId = e), this.assetId = new s(void 0, e);
+	}
+	getBoundingBox() {
+		let e = new a().makeEmpty();
+		return this.expandBoundingBox(e), e;
+	}
+	getStatus() {
+		return this.primitives.length === 0 ? n.Rejected : this.hasAssetRef ? n.Contextualized : this.status === "approved" ? n.Approved : this.status === "suggested" ? n.Suggested : n.Rejected;
+	}
+	setSelectedPrimitive(e) {
+		this.selectedIndex = this.primitives.indexOf(e);
+	}
+	removeSelectedPrimitive() {
+		let t = this.selectedPrimitive;
+		return this.selectedIndex = void 0, !(t === void 0 || !e(this.primitives, t));
+	}
+	expandBoundingBox(e) {
+		for (let t of this.primitives) t.expandBoundingBox(e);
+	}
+	remap(e) {
+		let t = e.find((e) => e.equalId(this));
+		if (t !== void 0) return this !== t && (t.selectedIndex = this.selectedIndex), t;
+	}
+	align(e) {
+		let { selectedPrimitive: t } = this;
+		if (t === void 0) return !1;
+		if (t instanceof r) t.rotation.x = 0, t.rotation.y = 0;
+		else if (t instanceof i) {
+			let n = t.centerA, r = t.centerB;
+			if (e ? n.z = r.z = (n.z + r.z) / 2 : (n.x = r.x = (n.x + r.x) / 2, n.y = r.y = (n.y + r.y) / 2), n.distanceTo(r) < t.radius / 4) return !1;
+		} else return !1;
+		return !0;
+	}
+	static create(e) {
+		let t = new o();
+		return t.selectedIndex = 0, t.status = "approved", t.primitives.push(e), t;
+	}
+	static areEqualIncludeSelected(e, t, n) {
+		return e === void 0 && t === void 0 ? !0 : e === void 0 || t === void 0 ? !1 : e === t && e.selectedIndex === n;
+	}
+	static areEqual(e, t) {
+		return e === void 0 && t === void 0 ? !0 : e === void 0 || t === void 0 ? !1 : e === t;
+	}
+};
+//#endregion
+export { c as Annotation, s as AssetCentricAssetId };

package/dist/domains/annotations/helpers/AnnotationChangedDescription.d.ts

@@ -0,0 +1,6 @@
+import { ChangedDescription } from '../../../foundation/domainObjectsHelpers/ChangedDescription';
+import { Annotation } from './Annotation';
+export declare class AnnotationChangedDescription extends ChangedDescription {
+    annotation: Annotation;
+    constructor(change: symbol, annotation: Annotation);
+}

package/dist/domains/annotations/helpers/AnnotationChangedDescription.js

@@ -0,0 +1,10 @@
+import { ChangedDescription as e } from "../../../foundation/domainObjectsHelpers/ChangedDescription.js";
+//#region libs/shared/reveal-components/src/domains/annotations/helpers/AnnotationChangedDescription.ts
+var t = class extends e {
+	annotation;
+	constructor(e, t) {
+		super(e), this.annotation = t;
+	}
+};
+//#endregion
+export { t as AnnotationChangedDescription };

package/dist/domains/annotations/helpers/AnnotationUtils.d.ts

@@ -0,0 +1,8 @@
+import { CogniteClient } from '@cognite/sdk';
+import { Annotation } from './Annotation';
+export declare class AnnotationUtils {
+    static update(sdk: CogniteClient, annotation: Annotation): Promise<boolean>;
+    static create(sdk: CogniteClient, annotation: Annotation): Promise<boolean>;
+    static delete(sdk: CogniteClient, annotation: Annotation): Promise<boolean>;
+    static fetchAllAnnotations(client: CogniteClient, modelId: number): Promise<Annotation[]>;
+}