@cognite/reveal-components 1.0.0

package/dist/domains/reveal/pointCloud/PointCloudThreeView.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/pointCloud/PointCloudThreeView.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 PointCloudThreeView };

package/dist/domains/reveal/pointCloud/commands/PointCloudFilterCommand.d.ts

@@ -0,0 +1,31 @@
+import { Color } from 'three';
+import { WellKnownAsprsPointClassCodes } from '@cognite/reveal';
+import { BaseFilterCommand, BaseFilterItemCommand } from '../../../../foundation/commands/BaseFilterCommand';
+import { TranslationInput } from '../../../../foundation/utilities/translation/TranslateInput';
+import { UniqueId } from '../../../../foundation/utilities/types';
+export declare class PointCloudFilterCommand extends BaseFilterCommand {
+    private _currentUniqueId;
+    get tooltip(): TranslationInput;
+    get isEnabled(): boolean;
+    initializeChildrenIfNeeded(): void;
+    protected createChildren(): FilterItemCommand[];
+    get isAllChecked(): boolean;
+    protected toggleAllCheckedCore(): boolean;
+    private getCurrentDomainObject;
+}
+export declare class FilterItemCommand extends BaseFilterItemCommand {
+    private readonly _pointClass;
+    private readonly _currentUniqueId;
+    constructor(pointClass: PointClass, currentUniqueId: UniqueId);
+    get tooltip(): TranslationInput;
+    get isChecked(): boolean;
+    get color(): Color | undefined;
+    protected setCheckedCore(value: boolean): boolean;
+}
+export declare class PointClass {
+    name: string;
+    code: number | WellKnownAsprsPointClassCodes;
+    color: Color;
+    constructor(name: string, code: number | WellKnownAsprsPointClassCodes, color: Color);
+    get displayName(): string;
+}

package/dist/domains/reveal/pointCloud/commands/PointCloudFilterCommand.js

@@ -0,0 +1,96 @@
+import { BaseFilterCommand as e, BaseFilterItemCommand as t } from "../../../../foundation/commands/BaseFilterCommand.js";
+import { PointCloudDomainObject as n } from "../PointCloudDomainObject.js";
+//#region libs/shared/reveal-components/src/domains/reveal/pointCloud/commands/PointCloudFilterCommand.ts
+var r = class extends e {
+	_currentUniqueId = void 0;
+	get tooltip() {
+		return { key: "POINTS_FILTER" };
+	}
+	get isEnabled() {
+		return this.getCurrentDomainObject() !== void 0;
+	}
+	initializeChildrenIfNeeded() {
+		let e = o(this.root);
+		if (e === void 0) {
+			this._children = void 0, this._currentUniqueId = void 0;
+			return;
+		}
+		this._currentUniqueId !== e.uniqueId && (this._currentUniqueId = e.uniqueId, this._children = void 0, super.initializeChildrenIfNeeded());
+	}
+	createChildren() {
+		let e = this.getCurrentDomainObject();
+		if (e === void 0 || !l(e.model)) return [];
+		let t = [];
+		for (let n of e.model.getClasses()) {
+			if (!e.model.hasClass(n.code)) continue;
+			let r = new a(n.name, n.code, n.color);
+			t.push(new i(r, e.uniqueId));
+		}
+		return t;
+	}
+	get isAllChecked() {
+		let e = this.getCurrentDomainObject();
+		return e !== void 0 && c(e.model);
+	}
+	toggleAllCheckedCore() {
+		let e = this.getCurrentDomainObject();
+		if (e === void 0) return !1;
+		let t = e.model;
+		if (!l(t)) return !1;
+		let n = c(t);
+		for (let e of t.getClasses()) t.setClassVisible(e.code, !n);
+		return !0;
+	}
+	getCurrentDomainObject() {
+		if (this._currentUniqueId !== void 0) return s(this.root, this._currentUniqueId);
+	}
+}, i = class extends t {
+	_pointClass;
+	_currentUniqueId;
+	constructor(e, t) {
+		super(), this._pointClass = e, this._currentUniqueId = t;
+	}
+	get tooltip() {
+		return { untranslated: this._pointClass.displayName };
+	}
+	get isChecked() {
+		let e = s(this.root, this._currentUniqueId);
+		return e !== void 0 && e.model.isClassVisible(this._pointClass.code);
+	}
+	get color() {
+		return this._pointClass.color;
+	}
+	setCheckedCore(e) {
+		let t = s(this.root, this._currentUniqueId);
+		return t === void 0 || t.model.isClassVisible(this._pointClass.code) === e ? !1 : (t.model.setClassVisible(this._pointClass.code, e), !0);
+	}
+}, a = class {
+	name;
+	code;
+	color;
+	constructor(e, t, n) {
+		this.name = e, this.code = t, this.color = n;
+	}
+	get displayName() {
+		let e = this.name, t = e.charAt(0).toUpperCase() + e.slice(1).replace(/_/g, " ");
+		return e.startsWith("ReservedOr") ? `${t.slice(10)} (legacy)` : t;
+	}
+};
+function o(e) {
+	for (let t of e.getDescendantsByType(n)) if (l(t.model)) return t;
+}
+function s(e, t) {
+	let r = e.getThisOrDescendantByUniqueId(t);
+	if (r !== void 0) return r instanceof n ? r : void 0;
+}
+function c(e) {
+	if (!l(e)) return !1;
+	for (let t of e.getClasses()) if (e.hasClass(t.code) && !e.isClassVisible(t.code)) return !1;
+	return !0;
+}
+function l(e) {
+	let t = e.getClasses();
+	return t === void 0 || t.length === 0 ? !1 : t.some((t) => e.hasClass(t.code));
+}
+//#endregion
+export { i as FilterItemCommand, a as PointClass, r as PointCloudFilterCommand };

package/dist/domains/reveal/pointCloud/commands/SetPointColorTypeCommand.d.ts

@@ -0,0 +1,10 @@
+import { PointColorType } from '@cognite/reveal';
+import { BaseOptionCommand } from '../../../../foundation/commands/BaseOptionCommand';
+import { RevealRenderTarget } from '../../../../foundation/renderTarget/RevealRenderTarget';
+import { TranslationInput } from '../../../../foundation/utilities/translation/TranslateInput';
+export declare class SetPointColorTypeCommand extends BaseOptionCommand {
+    constructor(supportedTypes?: PointColorType[]);
+    get tooltip(): TranslationInput;
+    get isEnabled(): boolean;
+    attach(renderTarget: RevealRenderTarget): void;
+}

package/dist/domains/reveal/pointCloud/commands/SetPointColorTypeCommand.js

@@ -0,0 +1,54 @@
+import { RenderTargetCommand as e } from "../../../../foundation/commands/RenderTargetCommand.js";
+import { BaseOptionCommand as t } from "../../../../foundation/commands/BaseOptionCommand.js";
+import { PointCloudDomainObject as n } from "../PointCloudDomainObject.js";
+import { PointColorType as r } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/domains/reveal/pointCloud/commands/SetPointColorTypeCommand.ts
+var i = [
+	r.Rgb,
+	r.Classification,
+	r.Depth,
+	r.Height,
+	r.Intensity
+], a = class extends t {
+	constructor(e = i) {
+		super();
+		for (let t of e) this.add(new o(t));
+	}
+	get tooltip() {
+		return { key: "POINT_COLOR" };
+	}
+	get isEnabled() {
+		return this.root.hasDescendantByType(n);
+	}
+	attach(e) {
+		super.attach(e), this.listenTo(this.settingsController.pointColorType);
+	}
+}, o = class extends e {
+	_value;
+	constructor(e) {
+		super(), this._value = e;
+	}
+	get tooltip() {
+		return s(this._value);
+	}
+	get isChecked() {
+		return this.settingsController.pointColorType() === this._value;
+	}
+	invokeCore() {
+		return this.settingsController.pointColorType(this._value), !0;
+	}
+};
+function s(e) {
+	switch (e) {
+		case r.Rgb: return { key: "RGB" };
+		case r.Depth: return { key: "DEPTH" };
+		case r.Height: return { key: "HEIGHT" };
+		case r.Classification: return { key: "CLASSIFICATION" };
+		case r.Intensity: return { key: "INTENSITY" };
+		case r.LevelOfDetail: return { untranslated: "LevelOfDetail" };
+		case r.PointIndex: return { untranslated: "PointIndex" };
+		default: return { untranslated: "Unknown" };
+	}
+}
+//#endregion
+export { a as SetPointColorTypeCommand };

package/dist/domains/reveal/pointCloud/commands/SetPointShapeCommand.d.ts

@@ -0,0 +1,10 @@
+import { PointShape } from '@cognite/reveal';
+import { BaseOptionCommand } from '../../../../foundation/commands/BaseOptionCommand';
+import { RevealRenderTarget } from '../../../../foundation/renderTarget/RevealRenderTarget';
+import { TranslationInput } from '../../../../foundation/utilities/translation/TranslateInput';
+export declare class SetPointShapeCommand extends BaseOptionCommand {
+    constructor(supportedTypes?: PointShape[]);
+    get tooltip(): TranslationInput;
+    get isEnabled(): boolean;
+    attach(renderTarget: RevealRenderTarget): void;
+}

package/dist/domains/reveal/pointCloud/commands/SetPointShapeCommand.js

@@ -0,0 +1,45 @@
+import { RenderTargetCommand as e } from "../../../../foundation/commands/RenderTargetCommand.js";
+import { BaseOptionCommand as t } from "../../../../foundation/commands/BaseOptionCommand.js";
+import { PointCloudDomainObject as n } from "../PointCloudDomainObject.js";
+import { PointShape as r } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/domains/reveal/pointCloud/commands/SetPointShapeCommand.ts
+var i = [
+	r.Circle,
+	r.Square,
+	r.Paraboloid
+], a = class extends t {
+	constructor(e = i) {
+		super();
+		for (let t of e) this.add(new o(t));
+	}
+	get tooltip() {
+		return { key: "POINT_SHAPE" };
+	}
+	get isEnabled() {
+		return this.root.hasDescendantByType(n);
+	}
+	attach(e) {
+		super.attach(e), this.listenTo(this.settingsController.pointShape);
+	}
+}, o = class extends e {
+	_value;
+	constructor(e) {
+		super(), this._value = e;
+	}
+	get tooltip() {
+		switch (this._value) {
+			case r.Circle: return { key: "CIRCLE" };
+			case r.Square: return { key: "SQUARE" };
+			case r.Paraboloid: return { key: "PARABOLOID" };
+			default: throw Error("Unknown point shape");
+		}
+	}
+	get isChecked() {
+		return this.settingsController.pointShape() === this._value;
+	}
+	invokeCore() {
+		return this.settingsController.pointShape(this._value), !0;
+	}
+};
+//#endregion
+export { a as SetPointShapeCommand };

package/dist/domains/reveal/pointCloud/commands/SetPointSizeCommand.d.ts

@@ -0,0 +1,15 @@
+import { BaseSliderCommand } from '../../../../foundation/commands/BaseSliderCommand';
+import { RevealRenderTarget } from '../../../../foundation/renderTarget/RevealRenderTarget';
+import { TranslationInput } from '../../../../foundation/utilities/translation/TranslateInput';
+export declare const POINT_SIZES: number[];
+export declare class SetPointSizeCommand extends BaseSliderCommand {
+    constructor();
+    getValueLabel(): string;
+    get tooltip(): TranslationInput;
+    get isEnabled(): boolean;
+    get value(): number;
+    set value(index: number);
+    get pointSize(): number;
+    set pointSize(value: number);
+    attach(renderTarget: RevealRenderTarget): void;
+}

package/dist/domains/reveal/pointCloud/commands/SetPointSizeCommand.js

@@ -0,0 +1,58 @@
+import { translate as e } from "../../../../foundation/utilities/translation/translateUtils.js";
+import { PointCloudDomainObject as t } from "../PointCloudDomainObject.js";
+import { BaseSliderCommand as n } from "../../../../foundation/commands/BaseSliderCommand.js";
+//#region libs/shared/reveal-components/src/domains/reveal/pointCloud/commands/SetPointSizeCommand.ts
+var r = [
+	0,
+	.025,
+	.05,
+	.075,
+	.1,
+	.2,
+	.3,
+	.4,
+	.5,
+	.6,
+	.8,
+	1,
+	1.5,
+	2,
+	2.5,
+	3,
+	4
+], i = class extends n {
+	constructor() {
+		super(0, r.length - 1, 1);
+	}
+	getValueLabel() {
+		let t = this.settingsController.pointSize();
+		return t === 0 ? e({ key: "MINIMUM" }) : t.toString();
+	}
+	get tooltip() {
+		return { key: "POINT_SIZE" };
+	}
+	get isEnabled() {
+		return this.root.hasDescendantByType(t);
+	}
+	get value() {
+		let e = this.pointSize, t = r.findIndex((t) => t === e);
+		return t >= 0 ? t : a(r, e);
+	}
+	set value(e) {
+		e >= 0 && e < r.length && (this.pointSize = r[e]);
+	}
+	get pointSize() {
+		return this.settingsController.pointSize();
+	}
+	set pointSize(e) {
+		this.settingsController.pointSize(e);
+	}
+	attach(e) {
+		super.attach(e), this.listenTo(this.settingsController.pointSize);
+	}
+};
+function a(e, t) {
+	return e.reduce((e, n, r, i) => Math.abs(n - t) < Math.abs(i[e] - t) ? r : e, 0);
+}
+//#endregion
+export { r as POINT_SIZES, i as SetPointSizeCommand };

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

@@ -0,0 +1,2 @@
+import { AnyIntersection, PointCloudIntersection } from '@cognite/reveal';
+export declare function isPointCloudIntersection(intersection: AnyIntersection | undefined): intersection is PointCloudIntersection;

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

@@ -0,0 +1,6 @@
+//#region libs/shared/reveal-components/src/domains/reveal/pointCloud/isPointCloudIntersection.ts
+function e(e) {
+	return e?.type === "pointcloud";
+}
+//#endregion
+export { e as isPointCloudIntersection };

package/dist/domains/reveal/signal/getRevealDomainObjectsSignal.d.ts

@@ -0,0 +1,4 @@
+import { RevealRenderTarget } from '../../../foundation/renderTarget/RevealRenderTarget';
+import { DisposableSignal } from '../../../utilities/signal/DisposableSignal';
+import { RevealDomainObject } from '../RevealDomainObject';
+export declare function getRevealDomainUpdateSignal(renderTarget: RevealRenderTarget, predicate?: (domainObject: RevealDomainObject) => boolean, additionalChangeFlags?: symbol[]): DisposableSignal<RevealDomainObject[]>;

package/dist/domains/reveal/signal/getRevealDomainObjectsSignal.js

@@ -0,0 +1,22 @@
+import { Changes as e } from "../../../foundation/domainObjectsHelpers/Changes.js";
+import { RevealDomainObject as t } from "../RevealDomainObject.js";
+import { filter as n } from "../../../foundation/utilities/extensions/generatorUtils.js";
+import { signal as r } from "@cognite/signal-utils";
+//#region libs/shared/reveal-components/src/domains/reveal/signal/getRevealDomainObjectsSignal.ts
+function i(n, i = () => !0, o = []) {
+	let s = r(() => a(n, i));
+	return n.root.views.addEventListener(c), {
+		signal: s,
+		dispose: () => {
+			n.root.views.removeEventListener(c);
+		}
+	};
+	function c(r, c) {
+		r instanceof t && c.isChanged(e.added, e.deleting, e.naming, ...o) && s(() => a(n, i));
+	}
+}
+function a(e, r) {
+	return [...n(e.root.getDescendantsByType(t), r)];
+}
+//#endregion
+export { i as getRevealDomainUpdateSignal };

package/dist/domains/reveal/utils/getViewer.d.ts

@@ -0,0 +1,3 @@
+import { Cognite3DViewer, DataSourceType } from '@cognite/reveal';
+import { RevealDomainObject } from '../RevealDomainObject';
+export declare function getViewer(domainObject: RevealDomainObject): Cognite3DViewer<DataSourceType> | undefined;

package/dist/domains/reveal/utils/getViewer.js

@@ -0,0 +1,9 @@
+import { getRenderTarget as e } from "../../../foundation/domainObjects/getRoot.js";
+import { RevealRenderTarget as t } from "../../../foundation/renderTarget/RevealRenderTarget.js";
+//#region libs/shared/reveal-components/src/domains/reveal/utils/getViewer.ts
+function n(n) {
+	let r = e(n);
+	if (r instanceof t) return r.viewer;
+}
+//#endregion
+export { n as getViewer };

package/dist/domains/reveal/utils/isImage360AnnotationHit.d.ts

@@ -0,0 +1,8 @@
+import { Vector2 } from 'three';
+import { Cognite3DViewer, DataSourceType } from '@cognite/reveal';
+/**
+ * Returns true when the click pixel lands on an interactive overlay element
+ * (e.g. a 360-image annotation polygon) that should consume the click instead
+ * of letting click-to-navigate fire.
+ */
+export declare function isImage360AnnotationHit(viewer: Cognite3DViewer<DataSourceType>, pixel: Vector2): Promise<boolean>;

package/dist/domains/reveal/utils/isImage360AnnotationHit.js

@@ -0,0 +1,6 @@
+//#region libs/shared/reveal-components/src/domains/reveal/utils/isImage360AnnotationHit.ts
+async function e(e, t) {
+	return await e.get360AnnotationIntersectionFromPixel(t.x, t.y) !== null;
+}
+//#endregion
+export { e as isImage360AnnotationHit };

package/dist/domains/reveal/utils/layersUrlStateParam.d.ts

@@ -0,0 +1,19 @@
+export type LayersUrlStateParam = {
+    image360Layers?: Image360LayersUrlStateParam[];
+    cadLayers?: CadLayersUrlStateParam[];
+    pointCloudLayers?: PointCloudLayersUrlStateParam[];
+};
+export type Image360LayersUrlStateParam = {
+    siteId: string;
+    applied: boolean;
+};
+export type CadLayersUrlStateParam = {
+    revisionId: number;
+    applied: boolean;
+    index: number;
+};
+export type PointCloudLayersUrlStateParam = {
+    revisionId: number;
+    applied: boolean;
+    index: number;
+};

package/dist/domains/reveal/utils/updateLayerState.d.ts

@@ -0,0 +1,6 @@
+import { RenderTarget } from '../../../foundation/renderTarget/RenderTarget';
+import { LayersUrlStateParam } from '../../../ui/components';
+export type SetLayersUrlStateParam = (layersState: LayersUrlStateParam | undefined) => void;
+export declare function updateLayerStateFromViewer(setLayersState: SetLayersUrlStateParam | undefined, renderTarget: RenderTarget): void;
+export declare function getLayerStateFromViewer(renderTarget: RenderTarget): LayersUrlStateParam;
+export declare function updateVisibilityFromURL(layersState: LayersUrlStateParam | undefined, renderTarget: RenderTarget): void;

package/dist/domains/reveal/utils/updateLayerState.js

@@ -0,0 +1,57 @@
+import { RevealDomainObject as e } from "../RevealDomainObject.js";
+import { Image360CollectionDomainObject as t } from "../Image360Collection/Image360CollectionDomainObject.js";
+import { PointCloudDomainObject as n } from "../pointCloud/PointCloudDomainObject.js";
+import { CadDomainObject as r } from "../cad/CadDomainObject.js";
+//#region libs/shared/reveal-components/src/domains/reveal/utils/updateLayerState.ts
+function i(i) {
+	let a = [], o = [], s = [], c = i.root.getDescendantsByType(e);
+	for (let e of c) {
+		let c = e.isVisible(i);
+		e instanceof r ? a.push({
+			revisionId: e.model.revisionId,
+			applied: c,
+			index: a.length
+		}) : e instanceof n ? o.push({
+			revisionId: e.model.revisionId,
+			applied: c,
+			index: o.length
+		}) : e instanceof t && s.push({
+			siteId: e.model.id,
+			applied: c
+		});
+	}
+	return {
+		cadLayers: a,
+		pointCloudLayers: o,
+		image360Layers: s
+	};
+}
+function a(e, i) {
+	if (e === void 0) return;
+	let { root: a } = i;
+	if (e.cadLayers !== void 0) {
+		let t = Array.from(a.getDescendantsByType(r));
+		for (let n of e.cadLayers) {
+			if (n.index >= t.length) continue;
+			let e = t[n.index];
+			e.model.revisionId === n.revisionId && e.setVisible(n.applied, i);
+		}
+	}
+	if (e.pointCloudLayers !== void 0) {
+		let t = Array.from(a.getDescendantsByType(n));
+		for (let n of e.pointCloudLayers) {
+			if (n.index >= t.length) continue;
+			let e = t[n.index];
+			e.model.revisionId === n.revisionId && e.setVisible(n.applied, i);
+		}
+	}
+	if (e.image360Layers !== void 0) {
+		let n = a.getDescendantsByType(t);
+		for (let t of n) {
+			let n = e.image360Layers.find((e) => e.siteId === t.model.id);
+			n !== void 0 && t.setVisible(n.applied, i);
+		}
+	}
+}
+//#endregion
+export { i as getLayerStateFromViewer, a as updateVisibilityFromURL };

package/dist/domains/scene/SceneDomainObject.d.ts

@@ -0,0 +1,41 @@
+import { CogniteInstanceId } from '@cognite/sdk';
+import { DomainObject } from '../../foundation/domainObjects/DomainObject';
+import { RevealRenderTarget } from '../../foundation/renderTarget/RevealRenderTarget';
+import { TranslationInput } from '../../foundation/utilities/translation/TranslateInput';
+import { IconName } from '../../foundation/utilities/types';
+import { Scene } from '../../ui/components/SceneContainer/sceneTypes';
+import { applyQualitySettingsToRenderTarget, applyResourceSettings } from '../../utilities/resourceSettings';
+import { fetchSceneConfig } from './fetchSceneConfig';
+import { loadGroundPlanes } from './loadSceneGroundPlanes';
+import { loadImage360Collections } from './loadSceneImage360Collections';
+import { loadSceneModels } from './loadSceneModels';
+import { loadPointsOfInterestForScene } from './loadScenePointsOfInterest';
+import { loadSkybox } from './loadSceneSkybox';
+export type SceneDomainObjectDeps = {
+    fetchSceneConfig: typeof fetchSceneConfig;
+    loadSceneModels: typeof loadSceneModels;
+    loadImage360Collections: typeof loadImage360Collections;
+    loadGroundPlanes: typeof loadGroundPlanes;
+    loadSkybox: typeof loadSkybox;
+    loadPointsOfInterestForScene: typeof loadPointsOfInterestForScene;
+    applyQualitySettingsToRenderTarget: typeof applyQualitySettingsToRenderTarget;
+    applyResourceSettings: typeof applyResourceSettings;
+};
+export declare const defaultSceneDomainObjectDeps: SceneDomainObjectDeps;
+export declare class SceneDomainObject extends DomainObject {
+    private readonly _sceneIdentifier;
+    private readonly _deps;
+    private _scene;
+    constructor(sceneIdentifier: CogniteInstanceId, deps?: SceneDomainObjectDeps);
+    get typeName(): TranslationInput;
+    get icon(): IconName;
+    get isVisibleInTree(): boolean;
+    get scene(): Scene | undefined;
+    get sceneIdentifier(): CogniteInstanceId;
+    /**
+     * Loads the scene from FDM and creates all resources (CAD, point clouds,
+     * image 360, skybox, ground planes) as domain objects. Uses the same
+     * query and logic as SceneContainer.
+     */
+    load(renderTarget: RevealRenderTarget): Promise<void>;
+}

package/dist/domains/scene/SceneDomainObject.js

@@ -0,0 +1,56 @@
+import { DomainObject as e } from "../../foundation/domainObjects/DomainObject.js";
+import { applyQualitySettingsToRenderTarget as t, applyResourceSettings as n } from "../../utilities/resourceSettings.js";
+import { fetchSceneConfig as r } from "./fetchSceneConfig.js";
+import { loadGroundPlanes as i } from "./loadSceneGroundPlanes.js";
+import { loadImage360Collections as a } from "./loadSceneImage360Collections.js";
+import { loadSceneModels as o } from "./loadSceneModels.js";
+import { loadPointsOfInterestForScene as s } from "./loadScenePointsOfInterest.js";
+import { loadSkybox as c } from "./loadSceneSkybox.js";
+import { assert as l } from "@cognite/underscore";
+//#region libs/shared/reveal-components/src/domains/scene/SceneDomainObject.ts
+var u = {
+	fetchSceneConfig: r,
+	loadSceneModels: o,
+	loadImage360Collections: a,
+	loadGroundPlanes: i,
+	loadSkybox: c,
+	loadPointsOfInterestForScene: s,
+	applyQualitySettingsToRenderTarget: t,
+	applyResourceSettings: n
+}, d = class extends e {
+	_sceneIdentifier;
+	_deps;
+	_scene = void 0;
+	constructor(e, t = u) {
+		super(), this._sceneIdentifier = e, this._deps = t, this.isExpanded = !0;
+	}
+	get typeName() {
+		return { key: "SCENE" };
+	}
+	get icon() {
+		return "Cubes";
+	}
+	get isVisibleInTree() {
+		return !0;
+	}
+	get scene() {
+		return this._scene;
+	}
+	get sceneIdentifier() {
+		return this._sceneIdentifier;
+	}
+	async load(e) {
+		let { fdmSdk: t } = e.root, n = this._deps;
+		this._scene = await n.fetchSceneConfig(t, this._sceneIdentifier);
+		let r = this._scene;
+		l(r !== void 0, "Scene not found"), this.name = r.sceneConfiguration.name;
+		let i = r.sceneConfiguration.qualitySettings;
+		i !== void 0 && n.applyQualitySettingsToRenderTarget(e, i), await n.loadSceneModels(e, r, this), await n.loadImage360Collections(e, r, this);
+		let a = await n.loadGroundPlanes(e, r), o = await n.loadPointsOfInterestForScene(e, this._sceneIdentifier);
+		a.forEach((e) => this.addChild(e)), o !== void 0 && this.addChild(o);
+		let s = r.skybox?.file === void 0 ? void 0 : await n.loadSkybox(e, r.skybox.file);
+		s !== void 0 && (this.addChild(s), s.setVisible(!0, e)), i !== void 0 && n.applyResourceSettings(e.revealSettingsController, i);
+	}
+};
+//#endregion
+export { d as SceneDomainObject, u as defaultSceneDomainObjectDeps };

package/dist/domains/scene/createResourceTransformation.d.ts

@@ -0,0 +1,9 @@
+import { Matrix4 } from 'three';
+import { Transformation3d } from '../../ui/components/SceneContainer/SceneFdmTypes';
+/**
+ * Creates a Matrix4 transform from Transformation3d properties.
+ * Uses the same logic as useReveal3dResourcesFromScene.
+ * Default to 1 in scale if scale is set to 0.
+ * Optional `cdfToViewerTransformation` defaults to `CDF_TO_VIEWER_TRANSFORMATION` from Reveal.
+ */
+export declare function createResourceTransformation(transformationData: Transformation3d, cdfToViewerTransformation?: Matrix4): Matrix4;

package/dist/domains/scene/createResourceTransformation.js

@@ -0,0 +1,15 @@
+import { Euler as e, MathUtils as t, Matrix4 as n } from "three";
+import { CDF_TO_VIEWER_TRANSFORMATION as r } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/domains/scene/createResourceTransformation.ts
+function i(i, a = r) {
+	let o = { ...i };
+	o.scaleX === 0 && (o.scaleX = 1), o.scaleY === 0 && (o.scaleY = 1), o.scaleZ === 0 && (o.scaleZ = 1);
+	let s = new n();
+	s.makeRotationFromEuler(new e(t.degToRad(o.eulerRotationX), t.degToRad(o.eulerRotationY), t.degToRad(o.eulerRotationZ), "XYZ"));
+	let c = new n().makeScale(o.scaleX, o.scaleY, o.scaleZ);
+	s.multiply(c);
+	let l = new n().makeTranslation(o.translationX, o.translationY, o.translationZ);
+	return s.premultiply(l), s.premultiply(a), s;
+}
+//#endregion
+export { i as createResourceTransformation };

package/dist/domains/scene/fetchSceneConfig.d.ts

@@ -0,0 +1,11 @@
+import { DirectRelationReference } from '@cognite/sdk';
+import { FdmSDK } from '../../data-providers/FdmSDK';
+import { Scene } from '../../ui/components/SceneContainer/sceneTypes';
+/**
+ * Fetches scene configuration from Data Modeling
+ * @param fdmSdk - The FDM SDK instance for querying
+ * @param sceneExternalId - External ID of the scene
+ * @param sceneSpace - Space of the scene
+ * @returns The scene configuration
+ */
+export declare function fetchSceneConfig(fdmSdk: FdmSDK, sceneIdentifier: DirectRelationReference): Promise<Scene | undefined>;