@cognite/reveal-components 1.0.0

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

@@ -0,0 +1,11 @@
+import { TranslationInput } from '../../foundation/utilities/translation/TranslateInput';
+import { IconName, ButtonType } from '../../foundation/utilities/types';
+import { PointsOfInterestCommand } from './PointsOfInterestCommand';
+export declare class DeleteSelectedPointsOfInterestCommand<PoiIdType> extends PointsOfInterestCommand<PoiIdType> {
+    get icon(): IconName;
+    get tooltip(): TranslationInput;
+    get buttonType(): ButtonType;
+    protected get shortCutKey(): string;
+    get isEnabled(): boolean;
+    protected invokeCore(): boolean;
+}

package/dist/domains/pointsOfInterest/DeletePointsOfInterestCommand.js

@@ -0,0 +1,25 @@
+import { PointsOfInterestCommand as e } from "./PointsOfInterestCommand.js";
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/DeletePointsOfInterestCommand.ts
+var t = class extends e {
+	get icon() {
+		return "Delete";
+	}
+	get tooltip() {
+		return { key: "POINT_OF_INTEREST_DELETE_THIS" };
+	}
+	get buttonType() {
+		return "ghost";
+	}
+	get shortCutKey() {
+		return "DELETE";
+	}
+	get isEnabled() {
+		return this.getPointsOfInterestDomainObject()?.selectedPointsOfInterest !== void 0;
+	}
+	invokeCore() {
+		let e = this.getPointsOfInterestDomainObject(), t = e?.selectedPointsOfInterest;
+		return e === void 0 || t === void 0 ? !1 : (e.removePointsOfInterest(t), e.setSelectedPointOfInterest(void 0), e.save(), !0);
+	}
+};
+//#endregion
+export { t as DeleteSelectedPointsOfInterestCommand };

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

@@ -0,0 +1,13 @@
+import { Vector3 } from 'three';
+import { RenderTargetCommand } from '../../foundation/commands/RenderTargetCommand';
+import { TranslationInput } from '../../foundation/utilities/translation/TranslateInput';
+import { IconName } from '../../foundation/utilities/types';
+export declare class InitiatePointsOfInterestCommand extends RenderTargetCommand {
+    private readonly _position;
+    private readonly _pointerEvent;
+    constructor(position: Vector3, clickEvent: PointerEvent);
+    get hasData(): boolean;
+    get icon(): IconName;
+    get tooltip(): TranslationInput;
+    protected invokeCore(): boolean;
+}

package/dist/domains/pointsOfInterest/InitiatePointsOfInterestCommand.js

@@ -0,0 +1,25 @@
+import { RenderTargetCommand as e } from "../../foundation/commands/RenderTargetCommand.js";
+import { PointsOfInterestTool as t } from "./PointsOfInterestTool.js";
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/InitiatePointsOfInterestCommand.ts
+var n = class extends e {
+	_position;
+	_pointerEvent;
+	constructor(e, t) {
+		super(), this._position = e, this._pointerEvent = t;
+	}
+	get hasData() {
+		return !0;
+	}
+	get icon() {
+		return "Waypoint";
+	}
+	get tooltip() {
+		return { key: "POINT_OF_INTEREST_CREATE" };
+	}
+	invokeCore() {
+		let e = this.renderTarget.commandsController.getToolByType(t);
+		return e !== void 0 && (this.renderTarget.commandsController.setActiveTool(e), e.beginCreatePointOfInterest(this._position, this._pointerEvent), !0);
+	}
+};
+//#endregion
+export { n as InitiatePointsOfInterestCommand };

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

@@ -0,0 +1,17 @@
+import { RevealRenderTarget } from '../../foundation/renderTarget/RevealRenderTarget';
+import { PointsOfInterestDomainObject } from './PointsOfInterestDomainObject';
+import { GetPoiIntersection } from './types';
+export declare class PoiHoverScheduler<PoiIdType> {
+    private readonly _domainObject;
+    private _pending;
+    private _animationFrameId;
+    constructor(_domainObject: PointsOfInterestDomainObject<PoiIdType>);
+    schedule(renderTarget: RevealRenderTarget, event: PointerEvent, getPoiIntersection: GetPoiIntersection): void;
+    clear(renderTarget: RevealRenderTarget): void;
+    reset(): void;
+    dispose(): void;
+    private cancelScheduledAnimationFrame;
+    private apply;
+    private canPick;
+    private clearHover;
+}

package/dist/domains/pointsOfInterest/PoiHoverScheduler.js

@@ -0,0 +1,65 @@
+import { getRenderTarget as e } from "../../foundation/domainObjects/getRoot.js";
+import { isPointsOfInterestIntersection as t } from "./types.js";
+import { RevealRenderTarget as n } from "../../foundation/renderTarget/RevealRenderTarget.js";
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/PoiHoverScheduler.ts
+var r = class {
+	_domainObject;
+	_pending;
+	_animationFrameId;
+	constructor(e) {
+		this._domainObject = e;
+	}
+	schedule(e, t, n) {
+		if (!this.canPick(e)) {
+			this.clear(e);
+			return;
+		}
+		this._pending = {
+			renderTarget: e,
+			event: t,
+			getPoiIntersection: n
+		}, this._animationFrameId === void 0 && (this._animationFrameId = requestAnimationFrame(() => {
+			this._animationFrameId = void 0;
+			let e = this._pending;
+			this._pending = void 0, e !== void 0 && this.apply(e.renderTarget, e.event, e.getPoiIntersection);
+		}));
+	}
+	clear(e) {
+		this.cancelScheduledAnimationFrame(), this.clearHover(e);
+	}
+	reset() {
+		let t = e(this._domainObject);
+		if (t instanceof n) {
+			this.clear(t);
+			return;
+		}
+		this.cancelScheduledAnimationFrame(), this._domainObject.setHoveredPointOfInterest(void 0);
+	}
+	dispose() {
+		this.reset();
+	}
+	cancelScheduledAnimationFrame() {
+		this._pending = void 0, this._animationFrameId !== void 0 && (cancelAnimationFrame(this._animationFrameId), this._animationFrameId = void 0);
+	}
+	apply(e, n, r) {
+		if (!this.canPick(e)) {
+			this.clearHover(e);
+			return;
+		}
+		let i = r(n);
+		if (t(i) && i.domainObject === this._domainObject) {
+			this._domainObject.setHoveredPointOfInterest(i.userData), e.setNavigateCursor();
+			return;
+		}
+		this.clearHover(e);
+	}
+	canPick(e) {
+		return this._domainObject.pointsOfInterest.length > 0 && this._domainObject.isVisible(e);
+	}
+	clearHover(e) {
+		let t = this._domainObject.hoveredPointOfInterest !== void 0;
+		this._domainObject.setHoveredPointOfInterest(void 0), t && e.setDefaultCursor();
+	}
+};
+//#endregion
+export { r as PoiHoverScheduler };

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

@@ -0,0 +1,22 @@
+import { Signal } from '@cognite/signal-utils';
+import { TreeNodeType } from '../../foundation/treeNodes/tree-node-type/tree-node-type';
+import { CheckboxState, UniqueId } from '../../foundation/utilities/types';
+import { PointsOfInterestDomainObject } from './PointsOfInterestDomainObject';
+import { PointOfInterest } from './types';
+export declare class PointOfInterestTreeNode<PoiIdType> implements TreeNodeType {
+    readonly poi: PointOfInterest<PoiIdType>;
+    readonly domainObject: PointsOfInterestDomainObject<PoiIdType>;
+    isExpanded: boolean;
+    readonly isParent = false;
+    readonly isCheckboxEnabled = true;
+    constructor(poi: PointOfInterest<PoiIdType>, domainObject: PointsOfInterestDomainObject<PoiIdType>);
+    get updateSignal(): Signal<number>;
+    get id(): UniqueId;
+    get label(): string;
+    get isSelected(): boolean;
+    set isSelected(value: boolean);
+    get checkboxState(): CheckboxState;
+    onSelect(): void;
+    toggleVisible(): void;
+    getChildren(): Generator<TreeNodeType>;
+}

package/dist/domains/pointsOfInterest/PointOfInterestTreeNode.js

@@ -0,0 +1,43 @@
+import { CheckboxState as e } from "../../foundation/utilities/types.js";
+import { getRenderTarget as t } from "../../foundation/domainObjects/getRoot.js";
+import { getPointOfInterestKey as n } from "./types.js";
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/PointOfInterestTreeNode.ts
+var r = class {
+	poi;
+	domainObject;
+	isExpanded = !1;
+	isParent = !1;
+	isCheckboxEnabled = !0;
+	constructor(e, t) {
+		this.poi = e, this.domainObject = t;
+	}
+	get updateSignal() {
+		return this.domainObject.updateSignal;
+	}
+	get id() {
+		return n(this.poi);
+	}
+	get label() {
+		return this.poi.properties.name;
+	}
+	get isSelected() {
+		return this.domainObject.selectedPointsOfInterest === this.poi;
+	}
+	set isSelected(e) {
+		this.domainObject.setSelectedPointOfInterest(e ? this.poi : void 0);
+	}
+	get checkboxState() {
+		let n = t(this.domainObject), r = n !== void 0 && this.domainObject.getViewByTarget(n) !== void 0;
+		return this.domainObject.isPointOfInterestVisible(this.poi) && r ? e.All : e.None;
+	}
+	onSelect() {
+		this.domainObject.focusOn(this.poi);
+	}
+	toggleVisible() {
+		let e = this.domainObject.isPointOfInterestVisible(this.poi);
+		this.domainObject.setPointOfInterestVisible(this.poi, !e);
+	}
+	*getChildren() {}
+};
+//#endregion
+export { r as PointOfInterestTreeNode };

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

@@ -0,0 +1,18 @@
+import { DmsUniqueIdentifier } from '../../data-providers/FdmSDK';
+import { CommentProperties, PointsOfInterestInstance } from './models';
+import { PointsOfInterestProvider } from './PointsOfInterestProvider';
+/**
+ * A cache that takes care of loading the pois, but also buffers changes to the overlays
+ * list when e.g. adding or removing pois
+ */
+export declare class PointsOfInterestCache<PoiId> {
+    private readonly _poiProvider;
+    private readonly _poiCommentCache;
+    constructor(poiProvider: PointsOfInterestProvider<PoiId>);
+    getPoiCommentsForPoi(id: PoiId): Promise<CommentProperties[]>;
+    postCommentForPoi(id: PoiId, content: string): Promise<CommentProperties>;
+    fetchPoisForScene(sceneId: DmsUniqueIdentifier): Promise<Array<PointsOfInterestInstance<PoiId>>>;
+    deletePointsOfInterest(poiIds: PoiId[]): Promise<void>;
+    upsertPointsOfInterest(pois: Array<PointsOfInterestInstance<PoiId>>): Promise<Array<PointsOfInterestInstance<PoiId>>>;
+    getDataProvider(): PointsOfInterestProvider<PoiId>;
+}

package/dist/domains/pointsOfInterest/PointsOfInterestCache.js

@@ -0,0 +1,35 @@
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/PointsOfInterestCache.ts
+var e = class {
+	_poiProvider;
+	_poiCommentCache = /* @__PURE__ */ new Map();
+	constructor(e) {
+		this._poiProvider = e;
+	}
+	async getPoiCommentsForPoi(e) {
+		let n = t(e), r = this._poiCommentCache.get(n);
+		if (r !== void 0) return r;
+		let i = await this._poiProvider.getPointsOfInterestComments(e);
+		return this._poiCommentCache.set(n, i), i;
+	}
+	async postCommentForPoi(e, n) {
+		let r = await this._poiProvider.postPointsOfInterestComment(e, n), i = t(e), a = this._poiCommentCache.get(i);
+		return a === void 0 ? this._poiCommentCache.set(i, [r]) : a.push(r), r;
+	}
+	async fetchPoisForScene(e) {
+		return await this._poiProvider.fetchPointsOfInterest(e);
+	}
+	async deletePointsOfInterest(e) {
+		e.length !== 0 && await this._poiProvider.deletePointsOfInterest(e);
+	}
+	async upsertPointsOfInterest(e) {
+		return e.length === 0 ? [] : await this._poiProvider.upsertPointsOfInterest(e);
+	}
+	getDataProvider() {
+		return this._poiProvider;
+	}
+};
+function t(e) {
+	return typeof e == "string" ? e : JSON.stringify(e);
+}
+//#endregion
+export { e as PointsOfInterestCache };

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

@@ -0,0 +1,7 @@
+import { RenderTargetCommand } from '../../foundation/commands/RenderTargetCommand';
+import { PointsOfInterestDomainObject } from './PointsOfInterestDomainObject';
+import { PointsOfInterestTool } from './PointsOfInterestTool';
+export declare class PointsOfInterestCommand<PoiIdType> extends RenderTargetCommand {
+    protected getTool(): PointsOfInterestTool<PoiIdType> | undefined;
+    protected getPointsOfInterestDomainObject(): PointsOfInterestDomainObject<PoiIdType> | undefined;
+}

package/dist/domains/pointsOfInterest/PointsOfInterestCommand.js

@@ -0,0 +1,14 @@
+import { RenderTargetCommand as e } from "../../foundation/commands/RenderTargetCommand.js";
+import { PointsOfInterestDomainObject as t } from "./PointsOfInterestDomainObject.js";
+import { PointsOfInterestTool as n } from "./PointsOfInterestTool.js";
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/PointsOfInterestCommand.ts
+var r = class extends e {
+	getTool() {
+		return this.getActiveTool(n);
+	}
+	getPointsOfInterestDomainObject() {
+		return this.root.getDescendantByType(t);
+	}
+};
+//#endregion
+export { r as PointsOfInterestCommand };

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

@@ -0,0 +1,72 @@
+import { Box3 } from 'three';
+import { DmsUniqueIdentifier } from '../../data-providers/FdmSDK';
+import { VisualDomainObject } from '../../foundation/domainObjects/VisualDomainObject';
+import { VisibleState } from '../../foundation/domainObjectsHelpers/VisibleState';
+import { RenderTarget } from '../../foundation/renderTarget/RenderTarget';
+import { RevealRenderTarget } from '../../foundation/renderTarget/RevealRenderTarget';
+import { TreeNodeType } from '../../foundation/treeNodes/tree-node-type/tree-node-type';
+import { TranslationInput } from '../../foundation/utilities/translation/TranslateInput';
+import { IconName } from '../../foundation/utilities/types';
+import { CommentProperties, PointsOfInterestProperties, PointsOfInterestInstance } from './models';
+import { PointsOfInterestProvider } from './PointsOfInterestProvider';
+import { GetPoiIntersection, PointOfInterest } from './types';
+export declare class PointsOfInterestDomainObject<PoiIdType> extends VisualDomainObject {
+    private _selectedPointsOfInterest;
+    private _hoveredPointOfInterest;
+    private readonly _poiHoverScheduler;
+    private readonly _poisCache;
+    private _currentScene;
+    private _pointsOfInterest;
+    private readonly _hiddenPointsOfInterestIds;
+    constructor(poiProvider: PointsOfInterestProvider<PoiIdType>);
+    private getFocusBoundingBox;
+    get isVisibleInTree(): boolean;
+    get isParent(): boolean;
+    getChildren(): Generator<TreeNodeType>;
+    get typeName(): TranslationInput;
+    get icon(): IconName;
+    get hasIconColor(): boolean;
+    get hasIndexOnLabel(): boolean;
+    get canBeRemoved(): boolean;
+    expandBoundingBox(box: Box3): void;
+    isPointOfInterestVisible(poi: PointOfInterest<PoiIdType>): boolean;
+    setPointOfInterestVisible(poi: PointOfInterest<PoiIdType>, visible: boolean): void;
+    ensureVisible(renderTarget: RenderTarget): void;
+    canBeSetVisibleNow(_renderTarget: RenderTarget): boolean;
+    getVisibleState(renderTarget?: RenderTarget): VisibleState;
+    setVisible(visible: boolean, renderTarget?: RenderTarget | undefined, doNotifyVisibleStateChange?: boolean): boolean;
+    addPendingPointsOfInterest(poiData: PointsOfInterestProperties): PointOfInterest<PoiIdType>;
+    removePointsOfInterest(poiToDelete: PointOfInterest<PoiIdType>): void;
+    get pointsOfInterest(): Array<PointOfInterest<PoiIdType>>;
+    get selectedPointsOfInterest(): PointOfInterest<PoiIdType> | undefined;
+    get hoveredPointOfInterest(): PointOfInterest<PoiIdType> | undefined;
+    /**
+     * Updates hovered POI state only. Does not cancel a pending pick or restore the cursor.
+     * Use {@link clearHover} to stop hovering from pointer interaction.
+     */
+    setHoveredPointOfInterest(poi: PointOfInterest<PoiIdType> | undefined): void;
+    /**
+     * Schedules POI hover picking for the next animation frame.
+     * Multiple pointermoves in the same frame coalesce to a single intersection.
+     */
+    updateHoverFromPointer(renderTarget: RevealRenderTarget, event: PointerEvent, getPoiIntersection: GetPoiIntersection): void;
+    clearHover(renderTarget: RevealRenderTarget): void;
+    dispose(): void;
+    save(): Promise<Array<PointOfInterest<PoiIdType>>>;
+    setSelectedPointOfInterest(poi: PointOfInterest<PoiIdType> | undefined): void;
+    setSelected(value: boolean): boolean;
+    focusOn(poi: PointOfInterest<PoiIdType>): void;
+    private setAssociatedInstanceStyle;
+    updatePointsOfInterest(pois: Array<PointOfInterest<PoiIdType>>): Promise<Array<PointsOfInterestInstance<PoiIdType>>>;
+    startEditingPoi(poi: PointOfInterest<PoiIdType>): void;
+    stopEditingPoi(poi: PointOfInterest<PoiIdType>): void;
+    private replacePoiRef;
+    saveUpdatedPointOfInterest(poi: PointOfInterest<PoiIdType>, properties: Partial<PointsOfInterestProperties>): Promise<PointsOfInterestInstance<PoiIdType> | undefined>;
+    postCommentForPoi(poi: PointOfInterest<PoiIdType>, content: string): Promise<CommentProperties | undefined>;
+    getCommentsForPoi(poi: PointOfInterest<PoiIdType>): Promise<CommentProperties[]>;
+    hasPendingPointsOfInterest(): boolean;
+    hasPendingDeletionPointsOfInterest(): boolean;
+    getScene(): DmsUniqueIdentifier | undefined;
+    setCurrentScene(scene: DmsUniqueIdentifier | undefined): Promise<void>;
+    private resetHover;
+}

package/dist/domains/pointsOfInterest/PointsOfInterestDomainObject.js

@@ -0,0 +1,223 @@
+import { getRenderTarget as e, getRoot as t } from "../../foundation/domainObjects/getRoot.js";
+import { Changes as n } from "../../foundation/domainObjectsHelpers/Changes.js";
+import { VisibleState as r } from "../../foundation/domainObjectsHelpers/VisibleState.js";
+import { VisualDomainObject as i } from "../../foundation/domainObjects/VisualDomainObject.js";
+import { convertToViewerCoordinates as a } from "../../foundation/renderTarget/convertCoordinates.js";
+import { PointsOfInterestStatus as o, getPointOfInterestKey as s } from "./types.js";
+import { RevealRenderTarget as c } from "../../foundation/renderTarget/RevealRenderTarget.js";
+import { createInstanceStyleGroup as l } from "../../ui/components/Reveal3DResources/instanceStyleTranslation.js";
+import { PoiHoverScheduler as u } from "./PoiHoverScheduler.js";
+import { PointOfInterestTreeNode as d } from "./PointOfInterestTreeNode.js";
+import { PointsOfInterestCache as f } from "./PointsOfInterestCache.js";
+import { partition as p, remove as m } from "lodash-es";
+import { Box3 as h, Vector3 as g } from "three";
+import { DefaultNodeAppearance as _ } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/domains/pointsOfInterest/PointsOfInterestDomainObject.ts
+var v = Symbol("poi3d-selected-associated-instance-styling"), y = 2, b = class extends i {
+	_selectedPointsOfInterest;
+	_hoveredPointOfInterest;
+	_poiHoverScheduler;
+	_poisCache;
+	_currentScene = void 0;
+	_pointsOfInterest = [];
+	_hiddenPointsOfInterestIds = /* @__PURE__ */ new Set();
+	constructor(e) {
+		super(), this._poiHoverScheduler = new u(this), this._poisCache = new f(e);
+	}
+	getFocusBoundingBox(e) {
+		let t = a(new g(e.properties.positionX, e.properties.positionY, e.properties.positionZ));
+		return new h().expandByPoint(t).expandByScalar(y);
+	}
+	get isVisibleInTree() {
+		return this._pointsOfInterest.length > 0;
+	}
+	get isParent() {
+		return this._pointsOfInterest.length > 0;
+	}
+	*getChildren() {
+		for (let e of this._pointsOfInterest) yield new d(e, this);
+	}
+	get typeName() {
+		return { key: "POINT_OF_INTEREST_PLURAL" };
+	}
+	get icon() {
+		return "Waypoint";
+	}
+	get hasIconColor() {
+		return !1;
+	}
+	get hasIndexOnLabel() {
+		return !1;
+	}
+	get canBeRemoved() {
+		return !1;
+	}
+	expandBoundingBox(e) {
+		this._pointsOfInterest.forEach((t) => e.expandByPoint(new g(t.properties.positionX, t.properties.positionY, t.properties.positionZ)));
+	}
+	isPointOfInterestVisible(e) {
+		return !this._hiddenPointsOfInterestIds.has(s(e));
+	}
+	setPointOfInterestVisible(t, r) {
+		let i = s(t);
+		if (!this._hiddenPointsOfInterestIds.has(i) === r) return;
+		let a = e(this);
+		a !== void 0 && this.ensureVisible(a), r ? this._hiddenPointsOfInterestIds.delete(i) : this._hiddenPointsOfInterestIds.add(i), this.notify(n.geometry), this.notifyVisibleStateChange();
+	}
+	ensureVisible(e) {
+		super.setVisible(!0, e, !1);
+	}
+	canBeSetVisibleNow(e) {
+		return this._pointsOfInterest.length > 0;
+	}
+	getVisibleState(t) {
+		let n = t ?? e(this);
+		if (n === void 0 || this._pointsOfInterest.length === 0) return r.Disabled;
+		if (this.getViewByTarget(n) === void 0) return r.None;
+		let i = this._pointsOfInterest.filter((e) => this.isPointOfInterestVisible(e)).length;
+		return i === 0 ? r.None : i === this._pointsOfInterest.length ? r.All : r.Some;
+	}
+	setVisible(t, r = void 0, i = !0) {
+		let a = r ?? e(this);
+		return a === void 0 || (this.ensureVisible(a), !this._pointsOfInterest.some((e) => this.isPointOfInterestVisible(e) !== t)) ? !1 : (t ? this._hiddenPointsOfInterestIds.clear() : this._pointsOfInterest.forEach((e) => this._hiddenPointsOfInterestIds.add(s(e))), this.notify(n.geometry), i && this.notifyVisibleStateChange(), !0);
+	}
+	addPendingPointsOfInterest(e) {
+		let t = {
+			properties: e,
+			status: o.PendingCreation,
+			id: this._poisCache.getDataProvider().createNewId()
+		};
+		return this._pointsOfInterest.push(t), this.notify(n.geometry), t;
+	}
+	removePointsOfInterest(e) {
+		this._hoveredPointOfInterest === e && this.resetHover(), e.status === o.PendingCreation ? m(this._pointsOfInterest, (t) => e === t) : this._pointsOfInterest.includes(e) && (e.status = o.PendingDeletion), this.notify(n.geometry);
+	}
+	get pointsOfInterest() {
+		return this._pointsOfInterest;
+	}
+	get selectedPointsOfInterest() {
+		return this._selectedPointsOfInterest;
+	}
+	get hoveredPointOfInterest() {
+		return this._hoveredPointOfInterest;
+	}
+	setHoveredPointOfInterest(e) {
+		this._hoveredPointOfInterest !== e && (this._hoveredPointOfInterest = e, this.notify(n.hovered));
+	}
+	updateHoverFromPointer(e, t, n) {
+		this._poiHoverScheduler.schedule(e, t, n);
+	}
+	clearHover(e) {
+		this._poiHoverScheduler.clear(e);
+	}
+	dispose() {
+		this._poiHoverScheduler.dispose(), super.dispose();
+	}
+	async save() {
+		let e = t(this);
+		if (e === void 0 || e.fdmSdk === void 0) return [];
+		this._selectedPointsOfInterest?.status === o.PendingDeletion && this.setSelectedPointOfInterest(void 0);
+		let r = this._hoveredPointOfInterest;
+		r !== void 0 && (r.status === o.PendingDeletion || r.status === o.PendingCreation) && this.resetHover();
+		let [i, a] = p(this._pointsOfInterest, (e) => e.status === o.PendingDeletion), s = this._poisCache.deletePointsOfInterest(i.map((e) => e.id)), c = this._pointsOfInterest.filter((e) => e.status === o.PendingCreation), l = (await this._poisCache.upsertPointsOfInterest(c)).map((e) => ({
+			status: o.Default,
+			properties: e.properties,
+			id: e.id
+		}));
+		return this._pointsOfInterest = a.filter((e) => e.status === o.Default || e.status === o.PendingEditing).concat(l), await s, this.notify(n.geometry), l;
+	}
+	setSelectedPointOfInterest(e) {
+		if (this._selectedPointsOfInterest = e, this.setAssociatedInstanceStyle(e), this.notify(n.selected), e !== void 0) for (let e of this.root.getThisAndDescendants()) e === this ? super.setSelected(!1) : e.setSelected(!1);
+	}
+	setSelected(e) {
+		return this._selectedPointsOfInterest !== void 0 && this.setSelectedPointOfInterest(void 0), super.setSelected(e);
+	}
+	focusOn(t) {
+		this.setSelectedPointOfInterest(t);
+		let n = e(this);
+		n instanceof c && n.viewer.fitCameraToBoundingBox(this.getFocusBoundingBox(t));
+	}
+	setAssociatedInstanceStyle(t) {
+		let n = e(this);
+		if (!(n instanceof c)) return;
+		let r = n.instanceStylingController;
+		if (t?.properties.instanceRef === void 0) {
+			r?.setStylingGroup(v, void 0);
+			return;
+		}
+		let i = l([t.properties.instanceRef], _.Highlighted);
+		r?.setStylingGroup(v, i);
+	}
+	async updatePointsOfInterest(e) {
+		return await this._poisCache.upsertPointsOfInterest(e);
+	}
+	startEditingPoi(e) {
+		if (e.status !== o.Default) return;
+		let t = this.replacePoiRef(e, {
+			...e,
+			status: o.PendingEditing
+		});
+		t !== void 0 && this.setSelectedPointOfInterest(t);
+	}
+	stopEditingPoi(e) {
+		if (e.status !== o.PendingEditing) return;
+		let t = this.replacePoiRef(e, {
+			...e,
+			status: o.Default
+		});
+		t !== void 0 && this._selectedPointsOfInterest === e && this.setSelectedPointOfInterest(t);
+	}
+	replacePoiRef(e, t) {
+		let n = this._pointsOfInterest.indexOf(e);
+		if (n !== -1) return this._pointsOfInterest[n] = t, t;
+	}
+	async saveUpdatedPointOfInterest(e, t) {
+		if (![o.Default, o.PendingEditing].includes(e.status)) return;
+		let r = {
+			...e,
+			properties: {
+				...e.properties,
+				...t
+			}
+		}, [i] = await this._poisCache.upsertPointsOfInterest([r]);
+		if (i !== void 0) {
+			let t = this.replacePoiRef(e, {
+				...r,
+				status: o.Default,
+				properties: i.properties
+			});
+			t !== void 0 && this._selectedPointsOfInterest === e && this.setSelectedPointOfInterest(t);
+		}
+		return this.notify(n.geometry), i;
+	}
+	async postCommentForPoi(e, t) {
+		let r = await this._poisCache.postCommentForPoi(e.id, t);
+		return this.notify(n.addedPart), r;
+	}
+	async getCommentsForPoi(e) {
+		return await this._poisCache.getPoiCommentsForPoi(e.id);
+	}
+	hasPendingPointsOfInterest() {
+		return this._pointsOfInterest.some((e) => e.status === o.PendingCreation);
+	}
+	hasPendingDeletionPointsOfInterest() {
+		return this._pointsOfInterest.some((e) => e.status === o.PendingDeletion);
+	}
+	getScene() {
+		return this._currentScene;
+	}
+	async setCurrentScene(e) {
+		if (e === this._currentScene || (this.resetHover(), this._currentScene = e, this._pointsOfInterest = [], this._hiddenPointsOfInterestIds.clear(), e === void 0)) return;
+		let t = await this._poisCache.fetchPoisForScene(e);
+		this._pointsOfInterest = t.map((e) => ({
+			id: e.id,
+			properties: e.properties,
+			status: o.Default
+		})), this._pointsOfInterest.forEach((e) => this._hiddenPointsOfInterestIds.add(s(e))), this.notify(n.geometry);
+	}
+	resetHover() {
+		this._poiHoverScheduler.reset();
+	}
+};
+//#endregion
+export { b as PointsOfInterestDomainObject };

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

@@ -0,0 +1,13 @@
+import { DmsUniqueIdentifier } from '../../data-providers/FdmSDK';
+import { CommentProperties, PointsOfInterestInstance, PointsOfInterestProperties } from './models';
+export type PointsOfInterestProvider<ID> = {
+    upsertPointsOfInterest: (pois: Array<{
+        id: ID;
+        properties: PointsOfInterestProperties;
+    }>) => Promise<Array<PointsOfInterestInstance<ID>>>;
+    fetchPointsOfInterest: (scene?: DmsUniqueIdentifier) => Promise<Array<PointsOfInterestInstance<ID>>>;
+    getPointsOfInterestComments: (poiId: ID) => Promise<CommentProperties[]>;
+    postPointsOfInterestComment: (poiId: ID, content: string) => Promise<CommentProperties>;
+    deletePointsOfInterest: (poiIds: ID[]) => Promise<void>;
+    createNewId: () => ID;
+};