@cognite/reveal-components 1.0.0

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

@@ -0,0 +1,59 @@
+import { Vector3 } from 'three';
+import { Signal } from '@cognite/signal-utils';
+import { DmsUniqueIdentifier } from '../../data-providers/FdmSDK';
+import { BaseEditTool } from '../../foundation/commands/BaseEditTool';
+import { TranslationInput } from '../../foundation/utilities/translation/TranslateInput';
+import { IconName } from '../../foundation/utilities/types';
+import { getInstancesFromClick } from '../../utilities/getInstancesFromClick';
+import { InstanceReference } from '../../utilities/instanceIds';
+import { PointsOfInterestDomainObject } from './PointsOfInterestDomainObject';
+import { PointOfInterest } from './types';
+export type PointsOfInterestToolDeps = {
+    getInstancesFromClick: typeof getInstancesFromClick;
+};
+export declare const defaultPointsOfInterestToolDeps: PointsOfInterestToolDeps;
+export declare class PointsOfInterestTool<PoiIdType> extends BaseEditTool {
+    private _isCreating;
+    private _scene;
+    /** Invalidates in-flight instance lookups for a cancelled/replaced draft. */
+    private _pendingCreateRequestId;
+    private readonly _lastCreatedPointOfInterest;
+    private readonly _pendingAssociatedInstance;
+    private readonly _isSaving;
+    private readonly _deps;
+    constructor(deps?: PointsOfInterestToolDeps);
+    get icon(): IconName;
+    protected get shortCutKey(): string;
+    onEscapeKey(): boolean;
+    get tooltip(): TranslationInput;
+    get isEnabled(): boolean;
+    onActivate(): void;
+    onDeactivate(): void;
+    onClick(event: PointerEvent): Promise<void>;
+    get lastCreatedPointOfInterest(): Signal<PointOfInterest<PoiIdType> | undefined>;
+    clearLastCreatedPointOfInterest(): void;
+    notifyPointOfInterestCreated(poi: PointOfInterest<PoiIdType>): void;
+    get isSaving(): Signal<boolean>;
+    setIsSaving(value: boolean): void;
+    startEditingSelectedPoi(): void;
+    stopEditingSelectedPoi(): void;
+    get pendingAssociatedInstance(): Signal<InstanceReference | undefined>;
+    private getPointsOfInterestDomainObject;
+    getOrCreatePointsOfInterestDomainObject(): PointsOfInterestDomainObject<PoiIdType>;
+    get isCreating(): boolean;
+    setIsCreating(value: boolean): void;
+    setScene(scene: DmsUniqueIdentifier | undefined): void;
+    private setAssignedInstance;
+    /**
+     * Starts POI creation by adding a pending draft at the given position and
+     * selecting it so the side panel can collect name/description.
+     *
+     * The mapped asset is resolved before the 3D overlay is added, matching
+     * production: CAD contextualization is picked first, then the draft is created.
+     */
+    beginCreatePointOfInterest(position: Vector3, clickEvent: PointerEvent): Promise<void>;
+    cancelPendingPointOfInterest(): void;
+    private initiateCreatePointOfInterest;
+    private removePendingDraft;
+    private selectOverlayFromClick;
+}

package/dist/domains/pointsOfInterest/PointsOfInterestTool.js

@@ -0,0 +1,148 @@
+import { PointsOfInterestStatus as e, createPointsOfInterestPropertiesFromPointAndTitle as t, isPointsOfInterestIntersection as n } from "./types.js";
+import { createInstanceStyleGroup as r } from "../../ui/components/Reveal3DResources/instanceStyleTranslation.js";
+import { PointsOfInterestDomainObject as i } from "./PointsOfInterestDomainObject.js";
+import { isImage360ClusterIntersection as a } from "../../foundation/utilities/misc/typeGuards.js";
+import { BaseEditTool as o } from "../../foundation/commands/BaseEditTool.js";
+import { getInstancesFromClick as s } from "../../utilities/getInstancesFromClick.js";
+import { PointsOfInterestAdsProvider as c } from "./ads/PointsOfInterestAdsProvider.js";
+import { signal as l } from "@cognite/signal-utils";
+import { DefaultNodeAppearance as u } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/PointsOfInterestTool.ts
+var d = Symbol("poi3d-assigned-instance-styling"), f = { getInstancesFromClick: s }, p = class extends o {
+	_isCreating = !1;
+	_scene;
+	_pendingCreateRequestId = 0;
+	_lastCreatedPointOfInterest = l(void 0);
+	_pendingAssociatedInstance = l(void 0);
+	_isSaving = l(!1);
+	_deps;
+	constructor(e = f) {
+		super(), this._deps = e;
+	}
+	get icon() {
+		return "Waypoint";
+	}
+	get shortCutKey() {
+		return "P";
+	}
+	onEscapeKey() {
+		return this.cancelPendingPointOfInterest(), !0;
+	}
+	get tooltip() {
+		return { key: "POINT_OF_INTEREST_CREATE" };
+	}
+	get isEnabled() {
+		return !this.renderTarget.isInside360Image && this._scene !== void 0;
+	}
+	onActivate() {
+		super.onActivate(), this.getOrCreatePointsOfInterestDomainObject().setVisible(!0, this.renderTarget), this.setIsCreating(!0), this.setCursor("copy");
+	}
+	onDeactivate() {
+		super.onDeactivate();
+		let t = this.getPointsOfInterestDomainObject(), n = t?.selectedPointsOfInterest;
+		n?.status !== e.PendingCreation && n?.status !== e.PendingEditing && t?.setSelectedPointOfInterest(void 0), this.setIsCreating(!1), this.setCursor("default"), this.setAssignedInstance(void 0);
+	}
+	async onClick(e) {
+		if (this._isCreating) {
+			this.setIsCreating(!1), this.renderTarget.activateDefaultTool(), await this.initiateCreatePointOfInterest(e);
+			return;
+		}
+		await this.selectOverlayFromClick(e);
+	}
+	get lastCreatedPointOfInterest() {
+		return this._lastCreatedPointOfInterest;
+	}
+	clearLastCreatedPointOfInterest() {
+		this._lastCreatedPointOfInterest(void 0);
+	}
+	notifyPointOfInterestCreated(e) {
+		this._lastCreatedPointOfInterest(e);
+	}
+	get isSaving() {
+		return this._isSaving;
+	}
+	setIsSaving(e) {
+		this._isSaving(e);
+	}
+	startEditingSelectedPoi() {
+		if (this._isSaving()) return;
+		let e = this.getPointsOfInterestDomainObject(), t = e?.selectedPointsOfInterest;
+		e !== void 0 && t !== void 0 && e.startEditingPoi(t);
+	}
+	stopEditingSelectedPoi() {
+		let e = this.getPointsOfInterestDomainObject(), t = e?.selectedPointsOfInterest;
+		e !== void 0 && t !== void 0 && e.stopEditingPoi(t);
+	}
+	get pendingAssociatedInstance() {
+		return this._pendingAssociatedInstance;
+	}
+	getPointsOfInterestDomainObject() {
+		return this.root.getDescendantByType(i);
+	}
+	getOrCreatePointsOfInterestDomainObject() {
+		let e = this.getPointsOfInterestDomainObject();
+		if (e !== void 0) return e;
+		let t = new i(new c(this.root.sdk));
+		return this.root.addChild(t), t;
+	}
+	get isCreating() {
+		return this._isCreating;
+	}
+	setIsCreating(e) {
+		this._isCreating = e, e ? this.renderTarget.setCrosshairCursor() : this.renderTarget.setNavigateCursor();
+	}
+	setScene(e) {
+		this._scene = e;
+	}
+	setAssignedInstance(e) {
+		if (e === void 0) {
+			this.renderTarget.instanceStylingController.setStylingGroup(d, void 0);
+			return;
+		}
+		let t = r([e], u.Highlighted);
+		this.renderTarget.instanceStylingController.setStylingGroup(d, t);
+	}
+	async beginCreatePointOfInterest(e, n) {
+		if (this._scene === void 0 || this._isSaving()) return;
+		let r = this.getOrCreatePointsOfInterestDomainObject();
+		this.removePendingDraft(r), this._pendingAssociatedInstance(void 0);
+		let i = ++this._pendingCreateRequestId, a;
+		try {
+			a = (await this._deps.getInstancesFromClick(this.renderTarget, n))?.[0];
+		} catch (e) {
+			console.error(e);
+		}
+		if (i !== this._pendingCreateRequestId || this._isSaving() || this._scene === void 0) return;
+		let o = r.addPendingPointsOfInterest(t(e, this._scene, "", "", a));
+		r.setVisible(!0, this.renderTarget), a !== void 0 && (this.setAssignedInstance(a), this._pendingAssociatedInstance(a)), r.setSelectedPointOfInterest(o), this.setIsCreating(!1), this.renderTarget.activateDefaultTool();
+	}
+	cancelPendingPointOfInterest() {
+		if (this._isSaving()) return;
+		this._pendingCreateRequestId++;
+		let e = this.getPointsOfInterestDomainObject();
+		e !== void 0 && (this.removePendingDraft(e), e.setSelectedPointOfInterest(void 0), e.pointsOfInterest.length === 0 && e.remove()), this._pendingAssociatedInstance(void 0), this.setAssignedInstance(void 0), this.setIsCreating(!1), this.renderTarget.activateDefaultTool();
+	}
+	async initiateCreatePointOfInterest(e) {
+		let t = await this.getIntersection(e);
+		if (t === void 0 || n(t) || a(t)) {
+			this.cancelPendingPointOfInterest();
+			return;
+		}
+		await this.beginCreatePointOfInterest(t.point, e);
+	}
+	removePendingDraft(t) {
+		t.pointsOfInterest.filter((t) => t.status === e.PendingCreation).forEach((e) => {
+			t.removePointsOfInterest(e);
+		});
+	}
+	async selectOverlayFromClick(e) {
+		let t = await this.getIntersection(e);
+		if (t === void 0 || !n(t)) {
+			await super.onClick(e);
+			return;
+		}
+		t.domainObject.focusOn(t.userData);
+	}
+};
+//#endregion
+export { p as PointsOfInterestTool, f as defaultPointsOfInterestToolDeps };

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

@@ -0,0 +1,25 @@
+import { Box3, PerspectiveCamera } from 'three';
+import { CustomObjectIntersectInput, CustomObjectIntersection } from '@cognite/reveal';
+import { DomainObjectChange } from '../../foundation/domainObjectsHelpers/DomainObjectChange';
+import { GroupThreeView } from '../../foundation/views/GroupThreeView';
+import { PointsOfInterestDomainObject } from './PointsOfInterestDomainObject';
+export declare class PointsOfInterestView<PoiIdType> extends GroupThreeView<PointsOfInterestDomainObject<PoiIdType>> {
+    private readonly _overlayCollection;
+    private _hoverSprite;
+    private _selectedSprite;
+    protected calculateBoundingBox(): Box3;
+    protected addChildren(): void;
+    update(change: DomainObjectChange): void;
+    beforeRender(camera: PerspectiveCamera): void;
+    intersectIfCloser(intersectInput: CustomObjectIntersectInput, closestDistance: number | undefined): undefined | CustomObjectIntersection;
+    clearMemory(): void;
+    dispose(): void;
+    private rebuildOverlays;
+    private ensureHighlightSprites;
+    private syncHighlights;
+    private applyOverlayVisibility;
+    private createHighlightSprite;
+    private scaleHighlightSprite;
+    private intersectOverlaysIfCloser;
+    private disposeHighlightSprites;
+}

package/dist/domains/pointsOfInterest/PointsOfInterestView.js

@@ -0,0 +1,105 @@
+import { Changes as e } from "../../foundation/domainObjectsHelpers/Changes.js";
+import { GroupThreeView as t } from "../../foundation/views/GroupThreeView.js";
+import { createPointsOfInterestIntersection as n } from "./types.js";
+import { RevealRenderTarget as r } from "../../foundation/renderTarget/RevealRenderTarget.js";
+import { POI_HIGHLIGHT_SIZE_SCALE as i, computeOverlayMatchingWorldDiameter as a } from "./computeOverlayMatchingWorldDiameter.js";
+import { getPoiMarkerTextures as o } from "./poiMarkerTextures.js";
+import { Box3 as s, PerspectiveCamera as c, Sphere as l, Sprite as u, SpriteMaterial as d, Vector3 as f } from "three";
+import { CDF_TO_VIEWER_TRANSFORMATION as p, ClosestGeometryFinder as m, Overlay3DCollection as h, isPointVisibleByPlanes as g } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/PointsOfInterestView.ts
+var _ = .5, v = 10, y = class extends t {
+	_overlayCollection = new h([], {
+		maxPointSize: 336,
+		minPointSize: 32,
+		overlayTexture: o().default
+	});
+	_hoverSprite;
+	_selectedSprite;
+	calculateBoundingBox() {
+		let e = new s().makeEmpty();
+		for (let t of this._overlayCollection.getOverlays()) t.getVisible() && e.expandByPoint(t.getPosition());
+		for (let t of [this._hoverSprite, this._selectedSprite]) t !== void 0 && t.visible && e.expandByPoint(t.position);
+		return e;
+	}
+	addChildren() {
+		this.rebuildOverlays(), this.addChild(this._overlayCollection), this.ensureHighlightSprites(), this.syncHighlights();
+	}
+	update(t) {
+		super.update(t), t.isChanged(e.geometry, e.dragging) ? (this.clearMemory(), this.invalidateRenderTarget(), this.invalidateBoundingBox(), this.ensureChildren()) : t.isChanged(e.clipping) ? (this.syncHighlights(), this.invalidateRenderTarget(), this.invalidateBoundingBox()) : t.isChanged(e.hovered, e.selected) && (this.syncHighlights(), this.invalidateRenderTarget());
+	}
+	beforeRender(e) {
+		super.beforeRender(e), this.scaleHighlightSprite(this._hoverSprite, e), this.scaleHighlightSprite(this._selectedSprite, e);
+	}
+	intersectIfCloser(e, t) {
+		let { domainObject: n } = this, r = new m(e.raycaster.ray.origin);
+		return t !== void 0 && (r.minDistance = t), this.intersectOverlaysIfCloser(e, r, n), r.getClosestGeometry();
+	}
+	clearMemory() {
+		this.disposeHighlightSprites(), this._overlayCollection.removeAllOverlays(), super.clearMemory();
+	}
+	dispose() {
+		this.disposeHighlightSprites(), this._overlayCollection.dispose(), super.dispose();
+	}
+	rebuildOverlays() {
+		this._overlayCollection.removeAllOverlays();
+		let e = this.domainObject.pointsOfInterest.filter((e) => this.domainObject.isPointOfInterestVisible(e)).map((e) => ({
+			position: b(e),
+			content: e
+		}));
+		this._overlayCollection.addOverlays(e);
+	}
+	ensureHighlightSprites() {
+		let e = o();
+		this._hoverSprite === void 0 && (this._hoverSprite = this.createHighlightSprite(e.hover), this.addChild(this._hoverSprite)), this._selectedSprite === void 0 && (this._selectedSprite = this.createHighlightSprite(e.selected), this.addChild(this._selectedSprite));
+	}
+	syncHighlights() {
+		if (this._overlayCollection.parent !== this._group) return;
+		this.ensureHighlightSprites();
+		let e = this._hoverSprite, t = this._selectedSprite;
+		if (e === void 0 || t === void 0) return;
+		let n = this.renderTarget.getGlobalClippingPlanes(), { selectedPointsOfInterest: r, hoveredPointOfInterest: i } = this.domainObject, a = r !== void 0 && this.domainObject.isPointOfInterestVisible(r), o = i !== void 0 && i !== r && this.domainObject.isPointOfInterestVisible(i);
+		a && r !== void 0 && t.position.copy(b(r)), o && i !== void 0 && e.position.copy(b(i)), t.visible = a && g(n, t.position), e.visible = o && g(n, e.position);
+		for (let e of this._overlayCollection.getOverlays()) this.applyOverlayVisibility(e, i, r, n);
+	}
+	applyOverlayVisibility(e, t, n, r) {
+		let i = e.getContent(), a = i === n || i === t, o = this.domainObject.isPointOfInterestVisible(i), s = g(r, e.getPosition());
+		e.setVisible(o && s && !a);
+	}
+	createHighlightSprite(e) {
+		let t = new d({
+			map: e,
+			depthTest: !1,
+			depthWrite: !1,
+			transparent: !0,
+			sizeAttenuation: !0
+		}), n = new u(t);
+		return n.center.set(.5, _), n.renderOrder = v, n.frustumCulled = !1, n.visible = !1, n;
+	}
+	scaleHighlightSprite(e, t) {
+		if (e === void 0 || !e.visible || !(this.renderTarget instanceof r)) return;
+		let n = a(t, e.position, this.renderTarget.viewer.canvas) * i;
+		e.scale.set(n, n, 1), e.updateMatrixWorld();
+	}
+	intersectOverlaysIfCloser(e, t, o) {
+		let s = e.camera;
+		if (!(s instanceof c) || !(this.renderTarget instanceof r)) return;
+		let u = this.renderTarget.getGlobalClippingPlanes(), d = e.raycaster.ray, p = new l(), m = new f(), h = this.renderTarget.viewer.canvas, { selectedPointsOfInterest: _, hoveredPointOfInterest: v } = this.domainObject;
+		for (let e of this._overlayCollection.getOverlays()) {
+			let r = e.getContent(), c = e.getPosition();
+			if (!this.domainObject.isPointOfInterestVisible(r) || !g(u, c)) continue;
+			let l = r === _ || r === v, f = a(s, c, h) * .5 * (l ? i : 1);
+			if (p.set(c, f), d.intersectSphere(p, m) === null || !t.isClosest(m)) continue;
+			let y = n(m.clone(), t.minDistance, this, o, r);
+			t.setClosestGeometry(y);
+		}
+	}
+	disposeHighlightSprites() {
+		for (let e of [this._hoverSprite, this._selectedSprite]) e !== void 0 && (e.material.map = null, e.material.dispose());
+		this._hoverSprite = void 0, this._selectedSprite = void 0;
+	}
+};
+function b(e) {
+	return new f(e.properties.positionX, e.properties.positionY, e.properties.positionZ).applyMatrix4(p);
+}
+//#endregion
+export { y as PointsOfInterestView };

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

@@ -0,0 +1,9 @@
+import { TranslationInput } from '../../foundation/utilities/translation/TranslateInput';
+import { PointsOfInterestCommand } from './PointsOfInterestCommand';
+export declare class SetPointsOfInterestVisibleCommand<PoiIdType> extends PointsOfInterestCommand<PoiIdType> {
+    get isToggle(): boolean;
+    get tooltip(): TranslationInput;
+    get isChecked(): boolean;
+    protected invokeCore(): boolean;
+    private get poiDomainObject();
+}

package/dist/domains/pointsOfInterest/SetPointsOfInterestVisibleCommand.js

@@ -0,0 +1,24 @@
+import { VisibleState as e } from "../../foundation/domainObjectsHelpers/VisibleState.js";
+import { PointsOfInterestDomainObject as t } from "./PointsOfInterestDomainObject.js";
+import { PointsOfInterestCommand as n } from "./PointsOfInterestCommand.js";
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/SetPointsOfInterestVisibleCommand.tsx
+var r = class extends n {
+	get isToggle() {
+		return !0;
+	}
+	get tooltip() {
+		return { key: "POINT_OF_INTEREST_PLURAL" };
+	}
+	get isChecked() {
+		return this.poiDomainObject?.getVisibleState(this.renderTarget) === e.All;
+	}
+	invokeCore() {
+		let e = !this.isChecked;
+		return this.poiDomainObject?.setVisible(e, this.renderTarget), !0;
+	}
+	get poiDomainObject() {
+		return this.root.getDescendantByType(t);
+	}
+};
+//#endregion
+export { r as SetPointsOfInterestVisibleCommand };

package/dist/domains/pointsOfInterest/ads/PointsOfInterestAdsProvider.d.ts

@@ -0,0 +1,23 @@
+import { CogniteClient } from '@cognite/sdk';
+import { DmsUniqueIdentifier, ExternalId } from '../../../data-providers/FdmSDK';
+import { CommentProperties, PointsOfInterestInstance } from '../models';
+import { PointsOfInterestProvider } from '../PointsOfInterestProvider';
+/**
+ * A PoI provider using the Cognite Application Data Storage service as backing storage
+ */
+export declare class PointsOfInterestAdsProvider implements PointsOfInterestProvider<ExternalId> {
+    private readonly _sdk;
+    private readonly _createUrl;
+    private readonly _listUrl;
+    private readonly _deleteUrl;
+    private readonly _getCommentsUrl;
+    private readonly _postCommentUrl;
+    private readonly _byidsUrl;
+    constructor(_sdk: CogniteClient);
+    upsertPointsOfInterest(pois: Array<PointsOfInterestInstance<ExternalId>>): Promise<Array<PointsOfInterestInstance<ExternalId>>>;
+    fetchPointsOfInterest(scene?: DmsUniqueIdentifier): Promise<Array<PointsOfInterestInstance<ExternalId>>>;
+    deletePointsOfInterest(poiIds: ExternalId[]): Promise<void>;
+    getPointsOfInterestComments(poiId: ExternalId): Promise<CommentProperties[]>;
+    postPointsOfInterestComment(poiId: ExternalId, content: string): Promise<CommentProperties>;
+    createNewId(): ExternalId;
+}

package/dist/domains/pointsOfInterest/ads/PointsOfInterestAdsProvider.js

@@ -0,0 +1,95 @@
+import { createUpsertRequestFromPois as e } from "./createUpsertRequestFromPois.js";
+import { createUserMap as t } from "./createUserMap.js";
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/ads/PointsOfInterestAdsProvider.ts
+var n = class {
+	_sdk;
+	_createUrl = (e) => `apps/v1/projects/${e}/storage/3d/poi`;
+	_listUrl = (e) => `apps/v1/projects/${e}/storage/3d/poi/list`;
+	_deleteUrl = (e) => `apps/v1/projects/${e}/storage/3d/poi/delete`;
+	_getCommentsUrl = (e) => `apps/v1/projects/${e}/storage/3d/poi/comment/list`;
+	_postCommentUrl = (e) => `apps/v1/projects/${e}/storage/3d/poi/comment`;
+	_byidsUrl = (e) => `apps/v1/projects/${e}/storage/3d/poi/byids`;
+	constructor(e) {
+		this._sdk = e;
+	}
+	async upsertPointsOfInterest(n) {
+		let i = e(n), a = await this._sdk.put(`${this._sdk.getBaseUrl()}/${this._createUrl(this._sdk.project)}`, { data: i });
+		if (a.status !== 200) throw Error(`An error occured while creating points of interest: ${JSON.stringify(a.data)}, status code: ${a.status}`);
+		let o = a.data.items.map((e) => e.ownerId), s = await t(this._sdk, o);
+		return a.data.items.forEach((e) => {
+			e.ownerId = s.get(e.ownerId) ?? "Unknown";
+		}), a.data.items.map(r);
+	}
+	async fetchPointsOfInterest(e) {
+		let n = await this._sdk.post(`${this._sdk.getBaseUrl()}/${this._listUrl(this._sdk.project)}`, { data: { filter: { scene: e } } });
+		if (n.status !== 200) throw Error(`An error occured while fetching points of interest: ${JSON.stringify(n.data)}, status code: ${n.status}`);
+		let i = n.data.items.map((e) => e.ownerId), a = await t(this._sdk, i);
+		return n.data.items.forEach((e) => {
+			e.ownerId = a.get(e.ownerId) ?? "Unknown";
+		}), n.data.items.map(r);
+	}
+	async deletePointsOfInterest(e) {
+		let t = await this._sdk.post(`${this._sdk.getBaseUrl()}/${this._deleteUrl(this._sdk.project)}`, { data: { items: e.map((e) => ({ externalId: e })) } });
+		if (t.status !== 200) throw Error(`An error occured while deleting points of interest: ${JSON.stringify(t.data)}, status code: ${t.status}`);
+	}
+	async getPointsOfInterestComments(e) {
+		let n = await this._sdk.post(`${this._sdk.getBaseUrl()}/${this._getCommentsUrl(this._sdk.project)}`, { data: { externalId: e } });
+		if (n.status !== 200) throw Error(`An error occured while fetching points of interest comments: ${JSON.stringify(n.data)}, status code: ${n.status}`);
+		let r = await t(this._sdk, n.data.map((e) => e.ownerId));
+		return n.data.forEach((e) => {
+			e.ownerId = r.get(e.ownerId) ?? "Unknown";
+		}), n.data;
+	}
+	async postPointsOfInterestComment(e, n) {
+		let r = await this._sdk.post(`${this._sdk.getBaseUrl()}/${this._postCommentUrl(this._sdk.project)}`, { data: {
+			poi3dExternalId: e,
+			content: n
+		} });
+		if (r.status !== 200) throw Error(`An error occured occured while posting points of interest comment: ${JSON.stringify(r.data)}, status code: ${r.status}`);
+		let i = (await t(this._sdk, [r.data.ownerId])).get(r.data.ownerId) ?? "Unknown";
+		return r.data.ownerId = i, r.data.createdTime = r.data.createdTime ?? Date.now(), r.data;
+	}
+	createNewId() {
+		return crypto.randomUUID();
+	}
+};
+function r(e) {
+	return {
+		id: e.externalId,
+		properties: {
+			name: e.name,
+			description: e.description,
+			ownerId: e.ownerId,
+			createdTime: e.createdTime,
+			lastUpdatedTime: e.lastUpdatedTime,
+			positionX: e.position[0],
+			positionY: e.position[1],
+			positionZ: e.position[2],
+			visibility: e.visibility,
+			scene: {
+				externalId: e.scene?.externalId ?? "dummy-scene-external-id",
+				space: e.scene?.space ?? "dummy-scene-space"
+			},
+			instanceRef: i(e?.assetRef),
+			sceneState: e.sceneState
+		}
+	};
+}
+function i(e) {
+	if (e !== void 0) {
+		if (a(e)) return { id: e.id };
+		if (o(e)) return {
+			externalId: e.externalId,
+			space: e.instanceSpace
+		};
+		throw Error("Unrecognized PoI external reference type");
+	}
+}
+function a(e) {
+	return e.id !== void 0;
+}
+function o(e) {
+	return e.externalId !== void 0 && e.instanceSpace !== void 0;
+}
+//#endregion
+export { n as PointsOfInterestAdsProvider };

package/dist/domains/pointsOfInterest/ads/createUpsertRequestFromPois.d.ts

@@ -0,0 +1,18 @@
+import { ExternalId, DmsUniqueIdentifier } from '../../../data-providers/FdmSDK';
+import { PointsOfInterestInstance, PoiVisibility, SceneState } from '../models';
+import { PoiExternalInstanceRef } from './types';
+type PoiUpsertObject = {
+    externalId: ExternalId;
+    name: string;
+    description: string;
+    position: [number, number, number];
+    sceneState: SceneState;
+    scene: DmsUniqueIdentifier;
+    visibility: PoiVisibility;
+    assetRef?: PoiExternalInstanceRef;
+};
+type PoiUpsertRequest = {
+    items: PoiUpsertObject[];
+};
+export declare function createUpsertRequestFromPois(pois: Array<PointsOfInterestInstance<ExternalId>>): PoiUpsertRequest;
+export {};

package/dist/domains/pointsOfInterest/ads/createUpsertRequestFromPois.js

@@ -0,0 +1,31 @@
+import { isDmsInstance as e, isInternalId as t } from "../../../utilities/instanceIds/typeGuards.js";
+import "../../../utilities/instanceIds/index.js";
+import { restrictToDmsId as n } from "../../../utilities/restrictToDmsId.js";
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/ads/createUpsertRequestFromPois.ts
+function r(e) {
+	return { items: e.map(({ id: e, properties: t }) => ({
+		externalId: e,
+		name: t.name ?? "",
+		description: t.description ?? "",
+		position: [
+			t.positionX,
+			t.positionY,
+			t.positionZ
+		],
+		sceneState: {},
+		scene: n(t.scene),
+		visibility: t.visibility ?? "PRIVATE",
+		assetRef: i(t.instanceRef)
+	})) };
+}
+function i(n) {
+	if (n !== void 0) {
+		if (t(n)) return n;
+		if (e(n)) return {
+			externalId: n.externalId,
+			instanceSpace: n.space
+		};
+	}
+}
+//#endregion
+export { r as createUpsertRequestFromPois };

package/dist/domains/pointsOfInterest/ads/createUserMap.d.ts

@@ -0,0 +1,2 @@
+import { CogniteClient } from '@cognite/sdk';
+export declare function createUserMap(sdk: CogniteClient, userIds: string[]): Promise<Map<string, string | undefined>>;

package/dist/domains/pointsOfInterest/ads/createUserMap.js

@@ -0,0 +1,10 @@
+import { isDefined as e } from "../../../utilities/isDefined.js";
+import { uniq as t } from "lodash-es";
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/ads/createUserMap.ts
+async function n(n, r) {
+	if (r.length === 0) return /* @__PURE__ */ new Map();
+	let i = t(r), a = (await n.profiles.retrieve(i.map((e) => ({ userIdentifier: e })))).filter(e).map((e) => [e.userIdentifier, e.displayName ?? void 0]);
+	return new Map(a);
+}
+//#endregion
+export { n as createUserMap };

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

@@ -0,0 +1,54 @@
+import { Space, ExternalId, DmsUniqueIdentifier } from '../../../data-providers/FdmSDK';
+export type PoiExternalAssetRef = {
+    id: number;
+};
+export type PoiExternalDMRef = {
+    externalId: ExternalId;
+    instanceSpace: Space;
+};
+export type PoiExternalInstanceRef = PoiExternalAssetRef | PoiExternalDMRef;
+export type PoiUpsertRequestPayload = {
+    externalId: ExternalId;
+    name: string;
+    description?: string;
+    position: Vec3;
+    sceneState: PoiSceneState;
+    screenshotFile: number;
+    scene: DmsUniqueIdentifier;
+    assetRef: PoiExternalInstanceRef;
+    visibility: PoiVisibility;
+};
+export type PoiItem = {
+    externalId: ExternalId;
+    ownerId: string;
+    name: string;
+    description?: string;
+    position: Vec3;
+    scene?: DmsUniqueIdentifier;
+    sceneState: PoiSceneState;
+    assetRef?: PoiExternalInstanceRef;
+    visibility: PoiVisibility;
+    createdTime: number;
+    lastUpdatedTime: number;
+};
+export type PoiSceneState = {
+    slicingPlanes?: PoiSlicingPlane[];
+    cameraPosition?: Vec3;
+    cameraTarget?: Vec3;
+};
+export type Vec3 = [number, number, number];
+/**
+ * A plane in three dimensions consisting of all poinst satisfying the equation a * x + b * y + c * z + d = 0
+ * The inside of the plane (the area that are kept visible) is the points where a * x + b * y + c * z + d > 0,
+ * while points giving a * x + b * y + c * z + d < 0 are invisible if the clipping plane is active
+ */
+export type PoiSlicingPlane = {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+};
+export declare enum PoiVisibility {
+    PRIVATE = "PRIVATE",
+    PUBLIC = "PUBLIC"
+}

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

@@ -0,0 +1,18 @@
+import { PerspectiveCamera, Vector3 } from 'three';
+export declare const POI_MARKER_PIXEL_SIZE = 336;
+/** Hover/selected sprites relative to the matching default overlay size. */
+export declare const POI_HIGHLIGHT_SIZE_SCALE = 1.1;
+/** Must match Overlay3DCollection's internal icon radius. */
+export declare const POI_OVERLAY_ICON_RADIUS = 0.4;
+export declare const POI_OVERLAY_ICON_DIAMETER: number;
+/** Must match Overlay3DCollection `minPointSize`. */
+export declare const POI_OVERLAY_MIN_PIXEL_SIZE = 32;
+/**
+ * World-space diameter that matches Overlay3DCollection point icons.
+ * Mirrors Overlay3DIcon.computeAdaptiveScaling (radius) × 2, same as Reveal's
+ * own hover sprites for 360 markers.
+ *
+ * @param canvas - The current viewer's WebGL canvas (`viewer.canvas`), not a
+ *   wrapper that may contain other canvases.
+ */
+export declare function computeOverlayMatchingWorldDiameter(camera: PerspectiveCamera, markerPosition: Vector3, canvas: HTMLCanvasElement): number;

package/dist/domains/pointsOfInterest/computeOverlayMatchingWorldDiameter.js

@@ -0,0 +1,9 @@
+import { MathUtils as e, Vector4 as t } from "three";
+var n = 1.1, r = .4, i = r * 2, a = 1e-5, o = new t();
+function s(t, n, s) {
+	if (s.clientWidth <= 0 || s.height <= 0 || (o.set(n.x, n.y, n.z, 1).applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix), o.w < a)) return i;
+	let c = s.height * t.projectionMatrix.elements[5] * (r / o.w), l = s.width / s.clientWidth;
+	return e.clamp(c, 32 * l, 336 * l) / c * i;
+}
+//#endregion
+export { n as POI_HIGHLIGHT_SIZE_SCALE, i as POI_OVERLAY_ICON_DIAMETER, r as POI_OVERLAY_ICON_RADIUS, s as computeOverlayMatchingWorldDiameter };

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

@@ -0,0 +1,8 @@
+import { Vector2 } from 'three';
+import { DomainObject } from '../../foundation/domainObjects/DomainObject';
+import { DomainObjectIntersection } from '../../foundation/domainObjectsHelpers/DomainObjectIntersection';
+import { RevealRenderTarget } from '../../foundation/renderTarget/RevealRenderTarget';
+/**
+ * POI-only pick at a pixel so CAD and point cloud cannot steal a marker hit.
+ */
+export declare function getPoiIntersectionFromPixel(renderTarget: RevealRenderTarget, root: DomainObject, pixel: Vector2): DomainObjectIntersection | undefined;