@cognite/reveal-components 1.0.0

package/dist/domains/reveal/RevealSettingsController.js

@@ -0,0 +1,170 @@
+import { clear as e } from "../../foundation/utilities/extensions/arrayUtils.js";
+import { DEFAULT_REVEAL_QUALITY_SETTINGS as t } from "./constants.js";
+import { Image360CollectionDomainObject as n } from "./Image360Collection/Image360CollectionDomainObject.js";
+import { PointCloudDomainObject as r } from "./pointCloud/PointCloudDomainObject.js";
+import { effect as i, signal as a } from "@cognite/signal-utils";
+import { FlexibleControlsType as o, isFlexibleCameraManager as s } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/domains/reveal/RevealSettingsController.ts
+var c = class {
+	_viewer;
+	_root;
+	_disposables = [];
+	get disposableCount() {
+		return this._disposables.length;
+	}
+	_qualitySettings = a(t);
+	_cameraKeyBoardSpeed = a(1);
+	_cameraControlsType = a(o.Orbit);
+	_pointSize = a(0);
+	_pointShape = a(0);
+	_pointColorType = a(0);
+	_isIconsVisible = a(!1);
+	_isAnnotationsVisible = a(!0);
+	_isOccludedIconsVisible = a(!1);
+	_iconsOpacity = a(0);
+	_imagesOpacity = a(0);
+	_isInitialized = /* @__PURE__ */ new Set();
+	constructor(e, t) {
+		this._viewer = e, this._root = t, this.copyDefaultValuesFromViewer(), this.addEffect(() => {
+			l(this._qualitySettings(), this._viewer);
+		}), this.addEffect(() => {
+			u(this.cameraKeyBoardSpeed(), this._viewer);
+		}), this.addEffect(() => {
+			d(this.cameraControlsType(), this._viewer);
+		}), this.addEffect(() => {
+			let e = this.pointSize();
+			this.forEachPointCloud((t) => {
+				t.pointSize(e);
+			});
+		}), this.addEffect(() => {
+			let e = this.pointShape();
+			this.forEachPointCloud((t) => {
+				t.pointShape(e);
+			});
+		}), this.addEffect(() => {
+			let e = this.pointColorType();
+			this.forEachPointCloud((t) => {
+				t.pointColorType(e);
+			});
+		}), this.addEffect(() => {
+			let e = this.isIconsVisible();
+			this.forEachImage360Collection((t) => {
+				t.isIconsVisible(e);
+			});
+		}), this.addEffect(() => {
+			let e = this.isAnnotationsVisible();
+			this.forEachImage360Collection((t) => {
+				t.isAnnotationsVisible(e);
+			});
+		}), this.addEffect(() => {
+			let e = this.isOccludedIconsVisible();
+			this.forEachImage360Collection((t) => {
+				t.isOccludedIconsVisible(e);
+			});
+		}), this.addEffect(() => {
+			let e = this.iconsOpacity();
+			this.forEachImage360Collection((t) => {
+				t.iconsOpacity(e);
+			});
+		}), this.addEffect(() => {
+			let e = this.imagesOpacity();
+			this.forEachImage360Collection((t) => {
+				t.imagesOpacity(e);
+			});
+		});
+	}
+	get qualitySettings() {
+		return this._qualitySettings;
+	}
+	get cameraKeyBoardSpeed() {
+		return this._cameraKeyBoardSpeed;
+	}
+	get cameraControlsType() {
+		return this._cameraControlsType;
+	}
+	get pointSize() {
+		return this.initializeSignalFromPointCloud(this._pointSize, (e) => e.pointSize());
+	}
+	get pointShape() {
+		return this.initializeSignalFromPointCloud(this._pointShape, (e) => e.pointShape());
+	}
+	get pointColorType() {
+		return this.initializeSignalFromPointCloud(this._pointColorType, (e) => e.pointColorType());
+	}
+	get isIconsVisible() {
+		return this.initializeSignalFromImage360Collection(this._isIconsVisible, (e) => e.isIconsVisible());
+	}
+	get isAnnotationsVisible() {
+		return this.initializeSignalFromImage360Collection(this._isAnnotationsVisible, (e) => e.isAnnotationsVisible());
+	}
+	get isOccludedIconsVisible() {
+		return this.initializeSignalFromImage360Collection(this._isOccludedIconsVisible, (e) => e.isOccludedIconsVisible());
+	}
+	get iconsOpacity() {
+		return this.initializeSignalFromImage360Collection(this._iconsOpacity, (e) => e.iconsOpacity());
+	}
+	get imagesOpacity() {
+		return this.initializeSignalFromImage360Collection(this._imagesOpacity, (e) => e.imagesOpacity());
+	}
+	dispose() {
+		for (let e of this._disposables) e();
+		e(this._disposables);
+	}
+	addDisposable(e) {
+		this._disposables.push(e);
+	}
+	addEffect(e) {
+		this.addDisposable(i(() => {
+			e();
+		}));
+	}
+	copyDefaultValuesFromViewer() {
+		let e = this._viewer.cameraManager;
+		s(e) && (this._cameraKeyBoardSpeed(e.options.keyboardSpeed), this._cameraControlsType(e.options.controlsType), e.addControlsTypeChangeListener(this._cameraControlsTypeChangeHandler), this._disposables.push(() => {
+			e.removeControlsTypeChangeListener(this._cameraControlsTypeChangeHandler);
+		}));
+	}
+	_cameraControlsTypeChangeHandler = (e) => {
+		let t = this._viewer.cameraManager;
+		s(t) && this._cameraControlsType(t.options.controlsType);
+	};
+	forEachPointCloud(e) {
+		if (this._root !== void 0) for (let t of this._root.getDescendantsByType(r)) e(t);
+	}
+	forEachImage360Collection(e) {
+		if (this._root !== void 0) for (let t of this._root.getDescendantsByType(n)) e(t);
+	}
+	initializeSignalFromImage360Collection(e, t) {
+		if (!this._isInitialized.has(e)) {
+			let n = p(this._root);
+			n !== void 0 && (e(t(n)), this._isInitialized.add(e));
+		}
+		return e;
+	}
+	initializeSignalFromPointCloud(e, t) {
+		if (!this._isInitialized.has(e)) {
+			let n = f(this._root);
+			n !== void 0 && (e(t(n)), this._isInitialized.add(e));
+		}
+		return e;
+	}
+};
+function l(e, t) {
+	t.setResolutionOptions(e.resolutionOptions), t.cadBudget = e.cadBudget, t.pointCloudBudget = e.pointCloudBudget;
+}
+function u(e, t) {
+	let n = t.cameraManager;
+	s(n) && (n.options.keyboardSpeed = e);
+}
+function d(e, t) {
+	let n = t.cameraManager;
+	s(n) && (n.options.controlsType = e);
+}
+function f(e) {
+	return e === void 0 ? void 0 : e.getDescendantByType(r);
+}
+function p(e) {
+	return e === void 0 ? void 0 : e.getDescendantByType(n);
+}
+//#endregion
+export { c as RevealSettingsController };

package/dist/domains/reveal/RevealTypes.d.ts

@@ -0,0 +1,4 @@
+import { CogniteCadModel, Image360Collection, CognitePointCloudModel, DataSourceType } from '@cognite/reveal';
+export type PointCloud = CognitePointCloudModel<DataSourceType>;
+export type Image360Model = Image360Collection<DataSourceType>;
+export type RevealModel = PointCloud | Image360Model | CogniteCadModel;

package/dist/domains/reveal/cad/CadDomainObject.d.ts

@@ -0,0 +1,39 @@
+import { Box3 } from 'three';
+import { NodeAppearance, NodeCollection, CogniteCadModel } from '@cognite/reveal';
+import { ILazyLoader } from '../../../foundation/treeNodes/tree-node-type/i-lazy-loader';
+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 { RevealDomainObject } from '../RevealDomainObject';
+export type StylingWithNodeCollection = {
+    collection: NodeCollection;
+    appearance: NodeAppearance;
+    importance?: number;
+};
+export declare class CadDomainObject extends RevealDomainObject {
+    private readonly _model;
+    private readonly _collections;
+    private _cadLazyLoader;
+    private _cadRootLoadState;
+    get model(): CogniteCadModel;
+    constructor(model: CogniteCadModel);
+    get typeName(): TranslationInput;
+    get icon(): IconName;
+    get hasIconColor(): boolean;
+    get isParent(): boolean;
+    get isExpanded(): boolean;
+    set isExpanded(value: boolean);
+    getChildren(_loader?: ILazyLoader): Generator<TreeNodeType>;
+    expandBoundingBox(boundingBox: Box3): void;
+    dispose(): void;
+    setDefaultStyling(appearance: NodeAppearance): void;
+    getDefaultStyling(): NodeAppearance;
+    getStyledNodeCollections(key: Symbol): StylingWithNodeCollection[] | undefined;
+    addStyledNodeCollections(key: Symbol, value: StylingWithNodeCollection[]): void;
+    removeStyledNodeCollections(key: Symbol): void;
+    /**
+     * Lazily creates the `CadLazyLoader` for model's CAD node hierarchy
+     */
+    private getCadLazyLoader;
+    private loadCadRootOnce;
+}

package/dist/domains/reveal/cad/CadDomainObject.js

@@ -0,0 +1,96 @@
+import { getRoot as e } from "../../../foundation/domainObjects/getRoot.js";
+import { Changes as t } from "../../../foundation/domainObjectsHelpers/Changes.js";
+import { VIEWER_TO_CDF_TRANSFORMATION as n } from "../../../foundation/renderTarget/convertCoordinates.js";
+import { RevealDomainObject as r } from "../RevealDomainObject.js";
+import { getViewer as i } from "../utils/getViewer.js";
+import { CadTreeNode as a } from "../../../foundation/treeNodes/cad-tree-node/cad-tree-node.js";
+import { CadLazyLoader as o } from "../../../foundation/treeNodes/cad-tree-node/cad-lazy-loader.js";
+import { CadTreeNodeViewAdapter as s } from "../../../foundation/treeNodes/cad-tree-node/cad-tree-node-view-adapter.js";
+import { ClassicInstanceMappingsSdk as c } from "../../../foundation/treeNodes/cad-tree-node/nodes-and-instance-mappings-sdk/classic-instance-mappings-sdk.js";
+import { NodesAndInstanceMappingsSdk as l } from "../../../foundation/treeNodes/cad-tree-node/nodes-and-instance-mappings-sdk/nodes-and-instance-mappings-sdk.js";
+//#region libs/shared/reveal-components/src/domains/reveal/cad/CadDomainObject.ts
+var u = class extends r {
+	_model;
+	_collections = /* @__PURE__ */ new Map();
+	_cadLazyLoader;
+	_cadRootLoadState = "idle";
+	get model() {
+		return this._model;
+	}
+	constructor(e) {
+		super(), this._model = e;
+	}
+	get typeName() {
+		return { untranslated: "CAD" };
+	}
+	get icon() {
+		return "Cubes";
+	}
+	get hasIconColor() {
+		return !1;
+	}
+	get isParent() {
+		return this.getCadLazyLoader() !== void 0;
+	}
+	get isExpanded() {
+		return super.isExpanded;
+	}
+	set isExpanded(e) {
+		e && !this.isExpanded && this._cadRootLoadState === "failed" && (this._cadRootLoadState = "idle"), super.isExpanded = e;
+	}
+	*getChildren(e) {
+		let t = this.getCadLazyLoader();
+		if (t === void 0) return;
+		let n = t.root;
+		if (n === void 0) {
+			this.loadCadRootOnce(t);
+			return;
+		}
+		for (let e of n.getChildren(t)) e instanceof a && (yield new s(e, t));
+	}
+	expandBoundingBox(e) {
+		let t = this.model;
+		e.union(t.getModelBoundingBox(void 0, !0).clone().applyMatrix4(n));
+	}
+	dispose() {
+		super.dispose(), this._collections.clear();
+		let e = i(this);
+		(e?.models?.includes(this._model) ?? !1) && e?.removeModel(this._model);
+	}
+	setDefaultStyling(e) {
+		this._model.setDefaultNodeAppearance(e);
+	}
+	getDefaultStyling() {
+		return this._model.getDefaultNodeAppearance();
+	}
+	getStyledNodeCollections(e) {
+		return this._collections.get(e);
+	}
+	addStyledNodeCollections(e, t) {
+		let n = this.getStyledNodeCollections(e);
+		n !== void 0 && n.forEach((e) => this.model.unassignStyledNodeCollection(e.collection)), this._collections.set(e, t), t.forEach((e) => this.model.assignStyledNodeCollection(e.collection, e.appearance, e.importance));
+	}
+	removeStyledNodeCollections(e) {
+		let t = this.getStyledNodeCollections(e);
+		t !== void 0 && (t.forEach((e) => this.model.unassignStyledNodeCollection(e.collection)), this._collections.delete(e));
+	}
+	getCadLazyLoader() {
+		if (this._cadLazyLoader !== void 0) return this._cadLazyLoader;
+		let t = e(this)?.sdk;
+		if (t === void 0) return;
+		let n = new l(t, new c(t));
+		return this._cadLazyLoader = new o(n, {
+			modelId: this._model.modelId,
+			revisionId: this._model.revisionId
+		}, { domainObject: this }), this._cadLazyLoader;
+	}
+	loadCadRootOnce(e) {
+		this._cadRootLoadState === "idle" && (this._cadRootLoadState = "loading", e.loadInitialRoot().catch((e) => {
+			console.error("Can not load CAD node hierarchy", e), this._cadRootLoadState = "failed";
+		}).finally(() => {
+			this._cadRootLoadState === "loading" && (this._cadRootLoadState = "idle"), this.notify(t.loaded);
+		}));
+	}
+};
+//#endregion
+export { u as CadDomainObject };

package/dist/domains/reveal/cad/CadDomainObjectUtils.d.ts

@@ -0,0 +1,21 @@
+import { CogniteCadModel, NodeIdNodeCollection } from '@cognite/reveal';
+import { CogniteClient } from '@cognite/sdk';
+import { CadInstanceMappingsCache } from '../../../data-providers/cache/cad/CadInstanceMappingsCache';
+import { calculateCadInstanceStylingGroups } from '../../../ui/components/Reveal3DResources/hooks/useCalculateCadStyling';
+import { InstanceStylingGroup } from '../../../utilities/modelIds';
+import { CadDomainObject, StylingWithNodeCollection } from './CadDomainObject';
+export type FindInstanceStylingGroupsForCadDomainObjectsDependencies = {
+    createNodeIdNodeCollection: (cogniteClient: CogniteClient, model: CogniteCadModel) => NodeIdNodeCollection;
+    calculateCadInstanceStylingGroups: typeof calculateCadInstanceStylingGroups;
+};
+/**
+ * Collection of utilities associated with CadDomainObjects. Non-instantiable
+ */
+export declare class CadDomainObjectUtils {
+    private constructor();
+    static readonly defaultFindInstanceStylingGroupsForCadDomainObjectsDependencies: FindInstanceStylingGroupsForCadDomainObjectsDependencies;
+    static findInstanceStylingGroupsForCadDomainObjects(instanceStylingGroups: InstanceStylingGroup[], domainObjects: CadDomainObject[], cogniteClient: CogniteClient, cadMappingsCache: CadInstanceMappingsCache, importance?: number, dependencies?: FindInstanceStylingGroupsForCadDomainObjectsDependencies): Promise<{
+        domainObject: CadDomainObject;
+        stylingInfo: StylingWithNodeCollection[];
+    }[]>;
+}

package/dist/domains/reveal/cad/CadDomainObjectUtils.js

@@ -0,0 +1,39 @@
+import { isSameModel as e } from "../../../utilities/isSameModel.js";
+import { isTreeIndexStylingGroup as t } from "../../../utilities/styling/stylingGroups.js";
+import { calculateCadInstanceStylingGroups as n } from "../../../ui/components/Reveal3DResources/hooks/useCalculateCadStyling.js";
+import { NodeIdNodeCollection as r, TreeIndexNodeCollection as i } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/domains/reveal/cad/CadDomainObjectUtils.ts
+var a = class t {
+	constructor() {}
+	static defaultFindInstanceStylingGroupsForCadDomainObjectsDependencies = {
+		createNodeIdNodeCollection: (e, t) => new r(e, t),
+		calculateCadInstanceStylingGroups: n
+	};
+	static async findInstanceStylingGroupsForCadDomainObjects(n, r, i, a, s, c = t.defaultFindInstanceStylingGroupsForCadDomainObjectsDependencies) {
+		let l = await c.calculateCadInstanceStylingGroups(r.map((e) => ({
+			...e.model,
+			type: "cad"
+		})), n, a);
+		return r.map((t) => ({
+			domainObject: t,
+			stylingInfo: l.filter((n) => e(n.model, t.model)).flatMap((e) => e.styleGroups.map((e) => o(e, t.model, i, s, c.createNodeIdNodeCollection)))
+		}));
+	}
+};
+function o(e, n, r, a, o) {
+	if (t(e)) return {
+		collection: new i(e.treeIndexSet),
+		appearance: e.style,
+		importance: a
+	};
+	{
+		let t = o(r, n);
+		return t.executeFilter(e.nodeIds), {
+			collection: t,
+			appearance: e.style,
+			importance: a
+		};
+	}
+}
+//#endregion
+export { a as CadDomainObjectUtils };

package/dist/domains/reveal/cad/CadFolder.d.ts

@@ -0,0 +1,6 @@
+import { FolderDomainObject } from '../../../foundation/domainObjects/FolderDomainObject';
+import { TranslationInput } from '../../../foundation/utilities/translation/TranslateInput';
+export declare class CadFolder extends FolderDomainObject {
+    constructor();
+    get typeName(): TranslationInput;
+}

package/dist/domains/reveal/cad/CadFolder.js

@@ -0,0 +1,12 @@
+import { FolderDomainObject as e } from "../../../foundation/domainObjects/FolderDomainObject.js";
+//#region libs/shared/reveal-components/src/domains/reveal/cad/CadFolder.ts
+var t = class extends e {
+	constructor() {
+		super(), this.isExpanded = !0;
+	}
+	get typeName() {
+		return { key: "CAD_MODELS" };
+	}
+};
+//#endregion
+export { t as CadFolder };

package/dist/domains/reveal/cad/CadThreeView.d.ts

@@ -0,0 +1,12 @@
+import { Box3 } from 'three';
+import { CogniteCadModel } from '@cognite/reveal';
+import { DomainObjectChange } from '../../../foundation/domainObjectsHelpers/DomainObjectChange';
+import { ThreeView } from '../../../foundation/views/ThreeView';
+import { CadDomainObject } from './CadDomainObject';
+export declare class CadThreeView extends ThreeView<CadDomainObject> {
+    get model(): CogniteCadModel;
+    update(change: DomainObjectChange): void;
+    onShow(): void;
+    onHide(): void;
+    protected calculateBoundingBox(): Box3;
+}

package/dist/domains/reveal/cad/CadThreeView.js

@@ -0,0 +1,25 @@
+import { Changes as e } from "../../../foundation/domainObjectsHelpers/Changes.js";
+import { ThreeView as t } from "../../../foundation/views/ThreeView.js";
+import { CDF_TO_VIEWER_TRANSFORMATION as n } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/domains/reveal/cad/CadThreeView.ts
+var r = class extends t {
+	get model() {
+		return this.domainObject.model;
+	}
+	update(t) {
+		super.update(t), t.isChanged(e.renderStyle) && this.invalidateRenderTarget();
+	}
+	onShow() {
+		let e = this.model;
+		super.onShow(), e.visible = !0;
+	}
+	onHide() {
+		let e = this.model;
+		e.visible = !1, super.onHide();
+	}
+	calculateBoundingBox() {
+		return this.domainObject.getBoundingBox().applyMatrix4(n);
+	}
+};
+//#endregion
+export { r as CadThreeView };

package/dist/domains/reveal/cad/commands/CadDividerCommand.d.ts

@@ -0,0 +1,4 @@
+import { DividerCommand } from '../../../../foundation/commands/DividerCommand';
+export declare class CadDividerCommand extends DividerCommand {
+    get isVisible(): boolean;
+}

package/dist/domains/reveal/cad/commands/SetGhostModeCommand.d.ts

@@ -0,0 +1,10 @@
+import { RenderTargetCommand } from '../../../../foundation/commands/RenderTargetCommand';
+import { TranslationInput } from '../../../../foundation/utilities/translation/TranslateInput';
+export declare class SetGhostModeCommand extends RenderTargetCommand {
+    get tooltip(): TranslationInput;
+    get isEnabled(): boolean;
+    get isToggle(): boolean;
+    get isChecked(): boolean;
+    setChecked(checked: boolean): void;
+    protected invokeCore(): boolean;
+}

package/dist/domains/reveal/cad/commands/SetGhostModeCommand.js

@@ -0,0 +1,24 @@
+import { RenderTargetCommand as e } from "../../../../foundation/commands/RenderTargetCommand.js";
+//#region libs/shared/reveal-components/src/domains/reveal/cad/commands/SetGhostModeCommand.ts
+var t = class extends e {
+	get tooltip() {
+		return { key: "GHOST_MODE" };
+	}
+	get isEnabled() {
+		return !0;
+	}
+	get isToggle() {
+		return !0;
+	}
+	get isChecked() {
+		return this.renderTarget.ghostMode;
+	}
+	setChecked(e) {
+		this.renderTarget.ghostMode = e;
+	}
+	invokeCore() {
+		return this.renderTarget.ghostMode = !this.renderTarget.ghostMode, !0;
+	}
+};
+//#endregion
+export { t as SetGhostModeCommand };

package/dist/domains/reveal/constants.d.ts

@@ -0,0 +1,2 @@
+import { QualitySettings } from '../../foundation/utilities/quality/QualitySettings';
+export declare const DEFAULT_REVEAL_QUALITY_SETTINGS: QualitySettings;

package/dist/domains/reveal/constants.js

@@ -0,0 +1,14 @@
+//#region libs/shared/reveal-components/src/domains/reveal/constants.ts
+var e = {
+	cadBudget: {
+		maximumRenderCost: 15e6,
+		highDetailProximityThreshold: 0
+	},
+	pointCloudBudget: { numberOfPoints: 3e6 },
+	resolutionOptions: {
+		maxRenderResolution: 14e5,
+		movingCameraResolutionFactor: .5
+	}
+};
+//#endregion
+export { e as DEFAULT_REVEAL_QUALITY_SETTINGS };

package/dist/domains/reveal/getOrCreateFolder.d.ts

@@ -0,0 +1,17 @@
+import { DomainObject } from '../../foundation/domainObjects/DomainObject';
+import { FolderDomainObject } from '../../foundation/domainObjects/FolderDomainObject';
+/**
+ * Gets an existing folder of the specified type from the parent's descendants,
+ * or creates a new one if it doesn't exist.
+ *
+ * When creating a new folder, it enforces a specific order:
+ * 1. CadFolder (first)
+ * 2. PointCloudFolder (second)
+ * 3. Image360CollectionFolder (third)
+ *
+ * @template T - The type of folder, must extend FolderDomainObject
+ * @param parent - The parent folder to search in or add the folder to
+ * @param folderType - The constructor of the folder type to get or create
+ * @returns The existing or newly created folder of the specified type
+ */
+export declare function getOrCreateFolder<T extends FolderDomainObject>(parent: DomainObject, folderType: new () => T): T;

package/dist/domains/reveal/getOrCreateFolder.js

@@ -0,0 +1,26 @@
+import { CadFolder as e } from "./cad/CadFolder.js";
+import { Image360CollectionFolder as t } from "./Image360Collection/Image360CollectionFolder.js";
+import { PointCloudFolder as n } from "./pointCloud/PointCloudFolder.js";
+//#region libs/shared/reveal-components/src/domains/reveal/getOrCreateFolder.ts
+function r(e, t) {
+	let n = e.getDescendantByType(t);
+	if (n !== void 0) return n;
+	n = new t();
+	let r = a(n);
+	if (r < 0) return e.addChild(n), n;
+	for (let t = 0; t < e.children.length; t++) {
+		let i = a(e.children[t]);
+		if (i < 0 || i > r) return e.addChild(n, t), n;
+	}
+	return e.addChild(n), n;
+	function a(e) {
+		return i.findIndex((t) => e instanceof t);
+	}
+}
+var i = [
+	e,
+	n,
+	t
+];
+//#endregion
+export { r as getOrCreateFolder };

package/dist/domains/reveal/pointCloud/PointCloudDomainObject.d.ts

@@ -0,0 +1,31 @@
+import { Box3 } from 'three';
+import { DataSourceType, PointCloudAppearance, PointColorType, PointShape } from '@cognite/reveal';
+import { Signal } from '@cognite/signal-utils';
+import { TranslationInput } from '../../../foundation/utilities/translation/TranslateInput';
+import { IconName } from '../../../foundation/utilities/types';
+import { RevealDomainObject } from '../RevealDomainObject';
+import { PointCloud } from '../RevealTypes';
+export type PointCloudObjectCollection = DataSourceType['pointCloudCollectionType'];
+export type PointCloudStylingWithObjectCollection = {
+    collection: PointCloudObjectCollection;
+    style: PointCloudAppearance;
+};
+export declare class PointCloudDomainObject extends RevealDomainObject {
+    private readonly _model;
+    readonly pointSize: Signal<number>;
+    readonly pointShape: Signal<PointShape>;
+    readonly pointColorType: Signal<PointColorType>;
+    private readonly _collections;
+    get model(): PointCloud;
+    constructor(model: PointCloud);
+    get typeName(): TranslationInput;
+    get icon(): IconName;
+    get hasIconColor(): boolean;
+    expandBoundingBox(boundingBox: Box3): void;
+    dispose(): void;
+    getDefaultStyling(): PointCloudAppearance;
+    setDefaultStyling(styling: PointCloudAppearance): void;
+    getStyledObjectCollections(key: Symbol): PointCloudStylingWithObjectCollection[] | undefined;
+    addStyledObjectCollections(key: Symbol, objectCollections: PointCloudStylingWithObjectCollection[], importance?: number): void;
+    removeStyledObjectCollections(key: Symbol): void;
+}

package/dist/domains/reveal/pointCloud/PointCloudDomainObject.js

@@ -0,0 +1,57 @@
+import { VIEWER_TO_CDF_TRANSFORMATION as e } from "../../../foundation/renderTarget/convertCoordinates.js";
+import { RevealDomainObject as t } from "../RevealDomainObject.js";
+import { getViewer as n } from "../utils/getViewer.js";
+import { signal as r } from "@cognite/signal-utils";
+//#region libs/shared/reveal-components/src/domains/reveal/pointCloud/PointCloudDomainObject.ts
+var i = class extends t {
+	_model;
+	pointSize = r(0);
+	pointShape = r(0);
+	pointColorType = r(0);
+	_collections = /* @__PURE__ */ new Map();
+	get model() {
+		return this._model;
+	}
+	constructor(e) {
+		super(), this._model = e, this.pointSize(e.pointSize), this.pointShape(e.pointShape), this.pointColorType(e.pointColorType), this.addEffect(() => {
+			this._model.pointSize = this.pointSize(), this._model.pointShape = this.pointShape(), this._model.pointColorType = this.pointColorType();
+		});
+	}
+	get typeName() {
+		return { untranslated: "PointCloud" };
+	}
+	get icon() {
+		return "PointCloud";
+	}
+	get hasIconColor() {
+		return !1;
+	}
+	expandBoundingBox(t) {
+		let n = this.model;
+		t.union(n.getModelBoundingBox().applyMatrix4(e));
+	}
+	dispose() {
+		super.dispose(), this._collections.clear();
+		let e = n(this);
+		(e?.models?.includes(this._model) ?? !1) && e?.removeModel(this._model);
+	}
+	getDefaultStyling() {
+		return this._model.getDefaultPointCloudAppearance();
+	}
+	setDefaultStyling(e) {
+		this._model.setDefaultPointCloudAppearance(e);
+	}
+	getStyledObjectCollections(e) {
+		return this._collections.get(e);
+	}
+	addStyledObjectCollections(e, t, n) {
+		let r = this.getStyledObjectCollections(e);
+		r !== void 0 && r.forEach((e) => this.model.unassignStyledObjectCollection(e.collection)), this._collections.set(e, t), t.forEach(({ collection: e, style: t }) => this.model.assignStyledObjectCollection(e, t, n));
+	}
+	removeStyledObjectCollections(e) {
+		let t = this.getStyledObjectCollections(e);
+		t !== void 0 && (t.forEach(({ collection: e }) => this.model.unassignStyledObjectCollection(e)), this._collections.delete(e));
+	}
+};
+//#endregion
+export { i as PointCloudDomainObject };

package/dist/domains/reveal/pointCloud/PointCloudFolder.d.ts

@@ -0,0 +1,6 @@
+import { FolderDomainObject } from '../../../foundation/domainObjects/FolderDomainObject';
+import { TranslationInput } from '../../../foundation/utilities/translation/TranslateInput';
+export declare class PointCloudFolder extends FolderDomainObject {
+    constructor();
+    get typeName(): TranslationInput;
+}

package/dist/domains/reveal/pointCloud/PointCloudFolder.js

@@ -0,0 +1,12 @@
+import { FolderDomainObject as e } from "../../../foundation/domainObjects/FolderDomainObject.js";
+//#region libs/shared/reveal-components/src/domains/reveal/pointCloud/PointCloudFolder.ts
+var t = class extends e {
+	constructor() {
+		super(), this.isExpanded = !0;
+	}
+	get typeName() {
+		return { key: "POINT_CLOUDS" };
+	}
+};
+//#endregion
+export { t as PointCloudFolder };

package/dist/domains/reveal/pointCloud/PointCloudThreeView.d.ts

@@ -0,0 +1,11 @@
+import { Box3 } from 'three';
+import { DomainObjectChange } from '../../../foundation/domainObjectsHelpers/DomainObjectChange';
+import { ThreeView } from '../../../foundation/views/ThreeView';
+import { PointCloudDomainObject } from './PointCloudDomainObject';
+export declare class PointCloudThreeView extends ThreeView<PointCloudDomainObject> {
+    private get model();
+    update(change: DomainObjectChange): void;
+    onShow(): void;
+    onHide(): void;
+    protected calculateBoundingBox(): Box3;
+}