@cognite/reveal-components 1.0.0

package/dist/domains/scene/fetchSceneConfig.js

@@ -0,0 +1,64 @@
+import { ENVIRONMENT_MAP_SOURCE as e, GROUND_PLANE_SOURCE as t, IMAGE_360_COLLECTION_SOURCE as n, REVISION_SOURCE as r, SCENE_SOURCE as i } from "../../ui/hooks/scenes/types.js";
+import { sceneQuery as a } from "../../ui/hooks/scenes/sceneQuery.js";
+import { isScene360CollectionEdge as o, isScene3dModelEdge as s, isSceneConfigurationProperties as c } from "../../ui/hooks/scenes/sceneResponseTypeGuards.js";
+import { fdmViewsExist as l } from "../../utilities/fdmViewsExist.js";
+import { getGroundPlanes as u, getImageCollections as d, getSceneModels as f, getSkybox as p } from "./parseSceneResponse.js";
+//#region libs/shared/reveal-components/src/domains/scene/fetchSceneConfig.ts
+async function m(a) {
+	return await l(a, [
+		i,
+		r,
+		n,
+		e,
+		t
+	]);
+}
+async function h(e, t) {
+	if (!await m(e)) return;
+	let n = {
+		...a,
+		parameters: {
+			sceneExternalId: t.externalId,
+			sceneSpace: t.space
+		}
+	}, r = await e.queryNodesAndEdges(n), i = g(r.items.myScene[0]?.properties);
+	return {
+		sceneConfiguration: {
+			name: i.name,
+			cameraTranslationX: i.cameraTranslationX,
+			cameraTranslationY: i.cameraTranslationY,
+			cameraTranslationZ: i.cameraTranslationZ,
+			cameraEulerRotationX: i.cameraEulerRotationX,
+			cameraEulerRotationY: i.cameraEulerRotationY,
+			cameraEulerRotationZ: i.cameraEulerRotationZ,
+			cameraTargetX: i.cameraTargetX,
+			cameraTargetY: i.cameraTargetY,
+			cameraTargetZ: i.cameraTargetZ,
+			updatedAt: i.updatedAt,
+			qualitySettings: {
+				cadBudget: i.cadBudget,
+				pointCloudBudget: i.pointCloudBudget,
+				maxRenderResolution: i.maxRenderResolution,
+				movingCameraResolutionFactor: i.movingCameraResolutionFactor,
+				pointCloudPointSize: i.pointCloudPointSize,
+				pointCloudPointShape: i.pointCloudPointShape,
+				pointCloudColor: i.pointCloudColor,
+				image360Transparency: i.image360Transparency,
+				image360MarkerAlpha: i.image360MarkerAlpha,
+				image360MarkerVisible: i.image360MarkerVisible,
+				image360XRay: i.image360XRay
+			}
+		},
+		skybox: p(r.items.skybox[0]?.properties),
+		groundPlanes: u(r.items.groundPlanes, r.items.groundPlaneEdges),
+		sceneModels: await f(r.items.sceneModels.filter(s), e),
+		image360Collections: d(r.items.image360CollectionsEdges.filter(o))
+	};
+}
+function g(e) {
+	let t = e.scene["SceneConfiguration/v1"];
+	if (!c(t)) throw Error("Scene configuration properties are missing or invalid");
+	return t;
+}
+//#endregion
+export { h as fetchSceneConfig };

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

@@ -0,0 +1,10 @@
+import { RevealRenderTarget } from '../../foundation/renderTarget/RevealRenderTarget';
+import { Scene } from '../../ui/components/SceneContainer/sceneTypes';
+import { initializeGroundPlane } from '../../ui/hooks/initializeGroundPlane';
+import { GroundPlaneDomainObject } from '../groundPlane/GroundPlaneDomainObject';
+import { loadTextureFromFileExternalId } from './loadTextureFromFileExternalId';
+export type LoadGroundPlanesDeps = {
+    loadTextureFromFileExternalId: typeof loadTextureFromFileExternalId;
+    initializeGroundPlane: typeof initializeGroundPlane;
+};
+export declare function loadGroundPlanes(renderTarget: RevealRenderTarget, scene: Scene, deps?: LoadGroundPlanesDeps): Promise<GroundPlaneDomainObject[]>;

package/dist/domains/scene/loadSceneGroundPlanes.js

@@ -0,0 +1,32 @@
+import { initializeGroundPlane as e } from "../../ui/hooks/initializeGroundPlane.js";
+import { loadTextureFromFileExternalId as t } from "./loadTextureFromFileExternalId.js";
+import { Vector2 as n, Vector3 as r } from "three";
+//#region libs/shared/reveal-components/src/domains/scene/loadSceneGroundPlanes.ts
+var i = {
+	loadTextureFromFileExternalId: t,
+	initializeGroundPlane: e
+};
+async function a(e, t, a = i) {
+	if ((t.groundPlanes?.length ?? 0) === 0) return [];
+	let { sdk: o } = e.root, c = s(t.sceneConfiguration.updatedAt), l = [];
+	for (let i of t.groundPlanes ?? []) try {
+		let t = await a.loadTextureFromFileExternalId(o, i.file), [s] = a.initializeGroundPlane({
+			texture: t,
+			wrapping: i.wrapping,
+			repeatUV: new n(i.repeatU, i.repeatV),
+			scaleXY: new n(i.scaleX, c ? i.scaleZ : i.scaleY),
+			translation: new r(i.translationX, i.translationY, i.translationZ),
+			rotation: new r(i.eulerRotationX, i.eulerRotationY, i.eulerRotationZ)
+		}, e);
+		l.push(s);
+	} catch (e) {
+		console.warn("Failed to load ground plane:", i, e);
+	}
+	return l;
+}
+var o = /* @__PURE__ */ new Date("2024-08-01T10:44:00.000Z");
+function s(e) {
+	return e !== void 0 && new Date(e) > o;
+}
+//#endregion
+export { a as loadGroundPlanes };

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

@@ -0,0 +1,11 @@
+import { DomainObject } from '../../foundation/domainObjects/DomainObject';
+import { RevealRenderTarget } from '../../foundation/renderTarget/RevealRenderTarget';
+import { Scene } from '../../ui/components/SceneContainer/sceneTypes';
+import { Image360CollectionDomainObject } from '../reveal/Image360Collection/Image360CollectionDomainObject';
+import { RevealDomainObjectUtils } from '../reveal/RevealDomainObjectUtils';
+export type LoadImage360CollectionsDeps = {
+    addImage360CollectionDomainObject: typeof RevealDomainObjectUtils.addImage360CollectionDomainObject;
+    warn: typeof console.warn;
+};
+export declare const defaultLoadImage360CollectionsDeps: LoadImage360CollectionsDeps;
+export declare function loadImage360Collections(renderTarget: RevealRenderTarget, scene: Scene, parentDomainObject: DomainObject, deps?: LoadImage360CollectionsDeps): Promise<Image360CollectionDomainObject[]>;

package/dist/domains/scene/loadSceneImage360Collections.js

@@ -0,0 +1,27 @@
+import { RevealDomainObjectUtils as e } from "../reveal/RevealDomainObjectUtils.js";
+import { createResourceTransformation as t } from "./createResourceTransformation.js";
+//#region libs/shared/reveal-components/src/domains/scene/loadSceneImage360Collections.ts
+var n = {
+	addImage360CollectionDomainObject: e.addImage360CollectionDomainObject,
+	warn: console.warn
+};
+async function r(e, r, i, a = n) {
+	let o = e.cdfCaches.coreDmOnly, s = [];
+	for (let n of r.image360Collections ?? []) try {
+		let r = t(n), c = {
+			source: o ? "cdm" : "dm",
+			externalId: n.image360CollectionExternalId,
+			space: n.image360CollectionSpace,
+			defaultVisible: n.defaultVisible
+		}, l = await a.addImage360CollectionDomainObject(e, c, {
+			defaultVisible: n.defaultVisible,
+			parent: i
+		});
+		l.model.setModelTransformation(r), s.push(l);
+	} catch (e) {
+		a.warn("Failed to load image 360 collection:", n, e);
+	}
+	return s;
+}
+//#endregion
+export { n as defaultLoadImage360CollectionsDeps, r as loadImage360Collections };

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

@@ -0,0 +1,15 @@
+import { getModelIdAndRevisionIdFromExternalId } from '../../data-providers/network/common/getModelIdAndRevisionIdFromExternalId';
+import { DomainObject } from '../../foundation/domainObjects/DomainObject';
+import { RevealRenderTarget } from '../../foundation/renderTarget/RevealRenderTarget';
+import { Scene } from '../../ui/components/SceneContainer/sceneTypes';
+import { CadDomainObject } from '../reveal/cad/CadDomainObject';
+import { PointCloudDomainObject } from '../reveal/pointCloud/PointCloudDomainObject';
+import { RevealDomainObjectUtils } from '../reveal/RevealDomainObjectUtils';
+export type LoadSceneModelsDeps = {
+    addCadDomainObject: typeof RevealDomainObjectUtils.addCadDomainObject;
+    addPointCloudDomainObject: typeof RevealDomainObjectUtils.addPointCloudDomainObject;
+    getModelIdAndRevisionIdFromExternalId: typeof getModelIdAndRevisionIdFromExternalId;
+    warn: typeof console.warn;
+};
+export declare const defaultLoadSceneModelsDeps: LoadSceneModelsDeps;
+export declare function loadSceneModels(renderTarget: RevealRenderTarget, scene: Scene, parent: DomainObject, deps?: LoadSceneModelsDeps): Promise<(CadDomainObject | PointCloudDomainObject)[]>;

package/dist/domains/scene/loadSceneModels.js

@@ -0,0 +1,62 @@
+import { isClassicModelIdentifier as e, isDMModelIdentifier as t } from "../../utilities/instanceIds/typeGuards.js";
+import { getModelIdAndRevisionIdFromExternalId as n } from "../../data-providers/network/common/getModelIdAndRevisionIdFromExternalId.js";
+import { RevealDomainObjectUtils as r } from "../reveal/RevealDomainObjectUtils.js";
+import { createResourceTransformation as i } from "./createResourceTransformation.js";
+//#region libs/shared/reveal-components/src/domains/scene/loadSceneModels.ts
+var a = {
+	addCadDomainObject: r.addCadDomainObject,
+	addPointCloudDomainObject: r.addPointCloudDomainObject,
+	getModelIdAndRevisionIdFromExternalId: n,
+	warn: console.warn
+};
+async function o(e, t, n, r = a) {
+	let i = [];
+	for (let a of t.sceneModels ?? []) try {
+		let t = await s(e, a, n, r);
+		t !== void 0 && i.push(t);
+	} catch (e) {
+		r.warn("Failed to load scene model:", a, e);
+	}
+	return i;
+}
+async function s(n, r, o, s = a) {
+	let c = i(r), { fdmSdk: l } = n.root, u, d, f, p;
+	if (e(r.modelIdentifier)) u = r.modelIdentifier.modelId, d = r.modelIdentifier.revisionId, f = {
+		modelId: u,
+		revisionId: d
+	}, p = {
+		modelId: u,
+		revisionId: d
+	};
+	else if (t(r.modelIdentifier)) {
+		let e = await s.getModelIdAndRevisionIdFromExternalId(r.modelIdentifier.revisionExternalId, r.modelIdentifier.revisionSpace, l);
+		u = e.modelId, d = e.revisionId, f = {
+			revisionExternalId: r.modelIdentifier.revisionExternalId,
+			revisionSpace: r.modelIdentifier.revisionSpace
+		}, p = {
+			revisionExternalId: r.modelIdentifier.revisionExternalId,
+			revisionSpace: r.modelIdentifier.revisionSpace
+		};
+	} else throw Error("Unknown model identifier type");
+	let m = await n.viewer.determineModelType(u, d);
+	if (m === "cad") {
+		let e = await s.addCadDomainObject(n, f, {
+			parent: o,
+			defaultVisible: r.defaultVisible
+		});
+		return e.model.setModelTransformation(c), e;
+	}
+	if (m === "pointcloud") {
+		let e = await s.addPointCloudDomainObject(n, p, {
+			parent: o,
+			defaultVisible: r.defaultVisible
+		});
+		return e.model.setModelTransformation(c), e;
+	}
+	throw s.warn(`Unknown model type "${m}" for model:`, {
+		modelId: u,
+		revisionId: d
+	}), Error(`Failed to load scene model: unknown type "${m}" (modelId: ${u}, revisionId: ${d})`);
+}
+//#endregion
+export { a as defaultLoadSceneModelsDeps, o as loadSceneModels };

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

@@ -0,0 +1,9 @@
+import { CogniteClient, CogniteInstanceId } from '@cognite/sdk';
+import { RevealRenderTarget } from '../../foundation/renderTarget/RevealRenderTarget';
+import { PointsOfInterestDomainObject } from '../pointsOfInterest/PointsOfInterestDomainObject';
+export type LoadScenePointsOfInterestDeps = {
+    createPointsOfInterestDomainObject: (sdk: CogniteClient) => PointsOfInterestDomainObject<string>;
+    warn: typeof console.warn;
+};
+export declare const defaultLoadScenePointsOfInterestDeps: LoadScenePointsOfInterestDeps;
+export declare function loadPointsOfInterestForScene(renderTarget: RevealRenderTarget, sceneIdentifier: CogniteInstanceId, deps?: LoadScenePointsOfInterestDeps): Promise<PointsOfInterestDomainObject<string> | undefined>;

package/dist/domains/scene/loadScenePointsOfInterest.js

@@ -0,0 +1,18 @@
+import { PointsOfInterestDomainObject as e } from "../pointsOfInterest/PointsOfInterestDomainObject.js";
+import { PointsOfInterestAdsProvider as t } from "../pointsOfInterest/ads/PointsOfInterestAdsProvider.js";
+//#region libs/shared/reveal-components/src/domains/scene/loadScenePointsOfInterest.ts
+var n = {
+	createPointsOfInterestDomainObject: (n) => new e(new t(n)),
+	warn: console.warn
+};
+async function r(e, t, r = n) {
+	try {
+		let n = r.createPointsOfInterestDomainObject(e.root.sdk);
+		return await n.setCurrentScene(t), n.pointsOfInterest.length === 0 ? void 0 : n;
+	} catch (e) {
+		r.warn("Failed to load points of interest for scene:", e);
+		return;
+	}
+}
+//#endregion
+export { n as defaultLoadScenePointsOfInterestDeps, r as loadPointsOfInterestForScene };

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

@@ -0,0 +1,9 @@
+import { RevealRenderTarget } from '../../foundation/renderTarget/RevealRenderTarget';
+import { SkyboxDomainObject } from '../skybox/SkyboxDomainObject';
+import { loadTextureFromFileExternalId } from './loadTextureFromFileExternalId';
+export type LoadSkyboxDeps = {
+    loadTextureFromFileExternalId: typeof loadTextureFromFileExternalId;
+    warn: typeof console.warn;
+};
+export declare const defaultLoadSkyboxDeps: LoadSkyboxDeps;
+export declare function loadSkybox(renderTarget: RevealRenderTarget, skyboxFileExternalId: string, deps?: LoadSkyboxDeps): Promise<SkyboxDomainObject | undefined>;

package/dist/domains/scene/loadSceneSkybox.js

@@ -0,0 +1,19 @@
+import { SkyboxDomainObject as e } from "../skybox/SkyboxDomainObject.js";
+import { loadTextureFromFileExternalId as t } from "./loadTextureFromFileExternalId.js";
+//#region libs/shared/reveal-components/src/domains/scene/loadSceneSkybox.ts
+var n = {
+	loadTextureFromFileExternalId: t,
+	warn: console.warn
+};
+async function r(t, r, i = n) {
+	let a = t.root.sdk;
+	try {
+		let t = await i.loadTextureFromFileExternalId(a, r);
+		return new e(t);
+	} catch (e) {
+		i.warn("Failed to load skybox with file external ID:", r, e);
+		return;
+	}
+}
+//#endregion
+export { n as defaultLoadSkyboxDeps, r as loadSkybox };

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

@@ -0,0 +1,15 @@
+import { Texture } from 'three';
+import { CogniteClient } from '@cognite/sdk';
+export type LoadTextureFromFileExternalIdDeps = {
+    loadTexture: (downloadUrl: string) => Promise<Texture>;
+};
+/**
+ * Loads a texture from a CDF file by external ID.
+ * Fetches the download URL and loads the texture using Three.js TextureLoader.
+ *
+ * @param sdk - The Cognite SDK instance
+ * @param fileExternalId - External ID of the file
+ * @param deps - Injectable dependencies (TextureLoader class)
+ * @returns The loaded texture
+ */
+export declare function loadTextureFromFileExternalId(sdk: CogniteClient, fileExternalId: string, deps?: LoadTextureFromFileExternalIdDeps): Promise<Texture>;

package/dist/domains/scene/loadTextureFromFileExternalId.js

@@ -0,0 +1,10 @@
+import { TextureLoader as e } from "three";
+//#region libs/shared/reveal-components/src/domains/scene/loadTextureFromFileExternalId.ts
+var t = { loadTexture: (t) => new e().loadAsync(t) };
+async function n(e, n, r = t) {
+	let [i] = await e.files.getDownloadUrls([{ externalId: n }]);
+	if (i === void 0) throw Error(`No download URL found for file ${n}`);
+	return r.loadTexture(i.downloadUrl);
+}
+//#endregion
+export { n as loadTextureFromFileExternalId };

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

@@ -0,0 +1,7 @@
+import { FdmSDK } from '../../data-providers/FdmSDK';
+import { SkyboxProperties, GroundPlaneResponse, GroundPlaneEdgeResponse, SceneModelsResponse, Image360CollectionsResponse } from '../../ui/components/SceneContainer/SceneFdmTypes';
+import { CadOrPointCloudModel, GroundPlane, Image360Collection, Skybox } from '../../ui/components/SceneContainer/sceneTypes';
+export declare function getSceneModels(sceneModels: SceneModelsResponse[], fdmSdk: FdmSDK): Promise<CadOrPointCloudModel[]>;
+export declare function getImageCollections(sceneModels: Image360CollectionsResponse[]): Image360Collection[];
+export declare function getGroundPlanes(groundPlaneResponse: GroundPlaneResponse[], groundPlaneEdgeResponse: GroundPlaneEdgeResponse[]): GroundPlane[];
+export declare function getSkybox(skyboxProperties: Record<string, Record<string, SkyboxProperties>> | undefined): Skybox | undefined;

package/dist/domains/scene/parseSceneResponse.js

@@ -0,0 +1,71 @@
+import { tryGetModelIdFromExternalId as e } from "../../utilities/tryGetModelIdFromExternalId.js";
+import { getRevisionExternalIdsAndSpaces as t } from "../../ui/hooks/network/getRevisionExternalIdAndSpace.js";
+//#region libs/shared/reveal-components/src/domains/scene/parseSceneResponse.ts
+function n(e) {
+	let t = Object.keys(e)[0];
+	if (t === void 0) throw Error("Cannot extract properties from empty object");
+	let n = Object.keys(e[t])[0];
+	if (n === void 0) throw Error(`Cannot extract nested properties: object['${t}'] is empty`);
+	return e[t][n];
+}
+async function r(r, i) {
+	if (r.length === 0) return [];
+	let a = r.map((e) => n(e.properties)), o = await t(r.map((e, t) => ({
+		modelExternalId: e.endNode.externalId,
+		revisionId: a[t].revisionId
+	})), i);
+	return r.map((t, n) => {
+		let r = a[n], i = o[n];
+		if (i !== void 0) return s(r, i);
+		let l = e(t.endNode.externalId);
+		if (l === void 0) throw Error(`Could not parse model Id from externalId ${t.endNode.externalId}`);
+		return c(r, l);
+	});
+}
+function i(e) {
+	return e.map((e) => ({ ...n(e.properties) }));
+}
+function a(e, t) {
+	return t.map((t) => {
+		let r = e.find((e) => e.externalId === t.endNode.externalId && e.space === t.endNode.space);
+		if (r === void 0) return;
+		let { label: i, file: a, wrapping: o, repeatU: s, repeatV: c } = n(r.properties), l = n(t.properties);
+		return {
+			label: i,
+			file: a,
+			wrapping: o,
+			repeatU: s ?? 1,
+			repeatV: c ?? 1,
+			...l
+		};
+	}).filter((e) => e !== void 0);
+}
+function o(e) {
+	if (e === void 0) return;
+	let { label: t, isSpherical: r, file: i } = n(e);
+	return {
+		label: t,
+		isSpherical: r,
+		file: i
+	};
+}
+function s(e, t) {
+	return {
+		modelIdentifier: {
+			revisionExternalId: t.revisionExternalId,
+			revisionSpace: t.revisionSpace
+		},
+		...e
+	};
+}
+function c(e, t) {
+	return {
+		modelIdentifier: {
+			modelId: t,
+			revisionId: e.revisionId
+		},
+		...e
+	};
+}
+//#endregion
+export { a as getGroundPlanes, i as getImageCollections, r as getSceneModels, o as getSkybox };

package/dist/domains/skybox/SkyboxDomainObject.d.ts

@@ -0,0 +1,15 @@
+import { Texture } from 'three';
+import { DomainObject } from '../../foundation/domainObjects/DomainObject';
+import { VisualDomainObject } from '../../foundation/domainObjects/VisualDomainObject';
+import { TranslationInput } from '../../foundation/utilities/translation/TranslateInput';
+import { IconName } from '../../foundation/utilities/types';
+export declare class SkyboxDomainObject extends VisualDomainObject {
+    texture: Texture;
+    constructor(texture: Texture);
+    get icon(): IconName;
+    get canChangeColor(): boolean;
+    get typeName(): TranslationInput;
+    get canBeRemoved(): boolean;
+    get hasIndexOnLabel(): boolean;
+    clone(what?: symbol): DomainObject;
+}

package/dist/domains/skybox/SkyboxDomainObject.js

@@ -0,0 +1,29 @@
+import { VisualDomainObject as e } from "../../foundation/domainObjects/VisualDomainObject.js";
+//#region libs/shared/reveal-components/src/domains/skybox/SkyboxDomainObject.ts
+var t = class t extends e {
+	texture;
+	constructor(e) {
+		super(), this.texture = e, this.setColor("black");
+	}
+	get icon() {
+		return "CloudFog";
+	}
+	get canChangeColor() {
+		return !1;
+	}
+	get typeName() {
+		return { key: "SKYBOX" };
+	}
+	get canBeRemoved() {
+		return !1;
+	}
+	get hasIndexOnLabel() {
+		return !1;
+	}
+	clone(e) {
+		let n = new t(this.texture);
+		return n.copyFrom(this, e), n;
+	}
+};
+//#endregion
+export { t as SkyboxDomainObject };

package/dist/domains/skybox/SkyboxView.d.ts

@@ -0,0 +1,8 @@
+import { GroupThreeView } from '../../foundation/views/GroupThreeView';
+import { SkyboxDomainObject } from './SkyboxDomainObject';
+export declare class SkyboxView extends GroupThreeView<SkyboxDomainObject> {
+    get shouldPick(): boolean;
+    get isPartOfBoundingBox(): boolean;
+    get useDepthTest(): boolean;
+    protected addChildren(): void;
+}

package/dist/domains/skybox/SkyboxView.js

@@ -0,0 +1,29 @@
+import { GroupThreeView as e } from "../../foundation/views/GroupThreeView.js";
+import { BackSide as t, Box3 as n, Mesh as r, MeshBasicMaterial as i, SphereGeometry as a } from "three";
+//#region libs/shared/reveal-components/src/domains/skybox/SkyboxView.ts
+var o = 10, s = "skyboxSavedNear", c = "skyboxSavedFar", l = class extends e {
+	get shouldPick() {
+		return !1;
+	}
+	get isPartOfBoundingBox() {
+		return !1;
+	}
+	get useDepthTest() {
+		return !1;
+	}
+	addChildren() {
+		let { domainObject: e } = this, l = new a(o, 20, 20), u = new i({
+			map: e.texture,
+			side: t,
+			depthWrite: !1
+		}), d = new r(l, u);
+		d.renderOrder = -2, d.frustumCulled = !1, Object.assign(d, { boundingBox: new n().makeEmpty() }), d.onBeforeRender = (e, t, n) => {
+			d.position.copy(n.position), d.updateMatrix(), d.updateMatrixWorld(!0), d.updateWorldMatrix(!1, !0), n.userData[s] = n.near, n.userData[c] = n.far, n.near = .1, n.far = 10.1, n.updateProjectionMatrix();
+		}, d.onAfterRender = (e, t, n) => {
+			let { userData: r } = n, i = r[s], a = r[c];
+			i !== void 0 && a !== void 0 && (n.near = i, n.far = a, n.updateProjectionMatrix());
+		}, this.addChild(d);
+	}
+};
+//#endregion
+export { l as SkyboxView };

package/dist/domains/skybox/index.d.ts

@@ -0,0 +1,2 @@
+export { SkyboxDomainObject } from './SkyboxDomainObject';
+export { SkyboxView } from './SkyboxView';

package/dist/domains/skybox/index.js

@@ -0,0 +1,3 @@
+import { SkyboxDomainObject as e } from "./SkyboxDomainObject.js";
+import "./SkyboxView.js";
+export { e as SkyboxDomainObject };

package/dist/domains/temporary/TemporaryFolder.d.ts

@@ -0,0 +1,9 @@
+import { FolderDomainObject } from '../../foundation/domainObjects/FolderDomainObject';
+import { TranslationInput } from '../../foundation/utilities/translation/TranslateInput';
+import { IconName } from '../../foundation/utilities/types';
+export declare class TemporaryFolder extends FolderDomainObject {
+    constructor();
+    get typeName(): TranslationInput;
+    get icon(): IconName;
+    get hasInfoIcon(): boolean;
+}

package/dist/domains/temporary/TemporaryFolder.js

@@ -0,0 +1,17 @@
+import { translate as e } from "../../foundation/utilities/translation/translateUtils.js";
+import { FolderDomainObject as t } from "../../foundation/domainObjects/FolderDomainObject.js";
+//#region libs/shared/reveal-components/src/domains/temporary/TemporaryFolder.ts
+var n = class extends t {
+	constructor() {
+		super(), this.tooltip = e({ key: "TEMPORARY_TOOLTIP" });
+	}
+	get typeName() {
+		return { key: "TEMPORARY" };
+	}
+	get icon() {}
+	get hasInfoIcon() {
+		return !0;
+	}
+};
+//#endregion
+export { n as TemporaryFolder };

package/dist/domains/temporary/getOrCreateTemporaryFolder.d.ts

@@ -0,0 +1,5 @@
+import { DomainObject } from '../../foundation/domainObjects/DomainObject';
+import { RootDomainObject } from '../../foundation/domainObjects/RootDomainObject';
+import { TemporaryFolder } from './TemporaryFolder';
+export declare function getOrCreateTemporaryFolder(root: RootDomainObject): TemporaryFolder;
+export declare function getOrCreateTemporaryFolderChild<T extends DomainObject>(root: RootDomainObject, folderType: new () => T): T;

package/dist/domains/temporary/getOrCreateTemporaryFolder.js

@@ -0,0 +1,16 @@
+import { TemporaryFolder as e } from "./TemporaryFolder.js";
+//#region libs/shared/reveal-components/src/domains/temporary/getOrCreateTemporaryFolder.ts
+function t(t) {
+	let n = t.getChildByType(e);
+	if (n !== void 0) return n;
+	let r = new e();
+	return r.isExpanded = !0, t.addChild(r), r;
+}
+function n(e, n) {
+	let r = t(e), i = r.getDescendantByType(n);
+	if (i !== void 0) return i;
+	let a = new n();
+	return a.isExpanded = !0, r.addChild(a), a;
+}
+//#endregion
+export { t as getOrCreateTemporaryFolder, n as getOrCreateTemporaryFolderChild };

package/dist/domains/terrain/SetTerrainVisibleCommand.d.ts

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

package/dist/domains/terrain/TerrainDomainObject.d.ts

@@ -0,0 +1,16 @@
+import { Box3 } from 'three';
+import { VisualDomainObject } from '../../foundation/domainObjects/VisualDomainObject';
+import { RenderStyle } from '../../foundation/renderStyles/RenderStyle';
+import { TranslationInput } from '../../foundation/utilities/translation/TranslateInput';
+import { RegularGrid2 } from './geometry/RegularGrid2';
+import { TerrainRenderStyle } from './TerrainRenderStyle';
+export declare class TerrainDomainObject extends VisualDomainObject {
+    private _grid;
+    get grid(): RegularGrid2 | undefined;
+    set grid(value: RegularGrid2 | undefined);
+    get renderStyle(): TerrainRenderStyle | undefined;
+    get typeName(): TranslationInput;
+    createRenderStyle(): RenderStyle | undefined;
+    verifyRenderStyle(style: RenderStyle): void;
+    expandBoundingBox(boundingBox: Box3): void;
+}

package/dist/domains/terrain/TerrainDomainObject.js

@@ -0,0 +1,36 @@
+import { VisualDomainObject as e } from "../../foundation/domainObjects/VisualDomainObject.js";
+import { TerrainRenderStyle as t } from "./TerrainRenderStyle.js";
+//#region libs/shared/reveal-components/src/domains/terrain/TerrainDomainObject.ts
+var n = class extends e {
+	_grid = void 0;
+	get grid() {
+		return this._grid;
+	}
+	set grid(e) {
+		this._grid = e;
+	}
+	get renderStyle() {
+		return this.getRenderStyle();
+	}
+	get typeName() {
+		return { untranslated: "Terrain" };
+	}
+	createRenderStyle() {
+		return new t();
+	}
+	verifyRenderStyle(e) {
+		if (!(e instanceof t)) return;
+		let { grid: n } = this;
+		if (n === void 0) return;
+		let { boundingBox: r } = n, i = r.z;
+		i.isEmpty || !i.hasSpan || (e.increment <= 0 || e.increment > i.delta || e.increment < i.delta / 200) && (e.increment = i.getBestIncrement(20));
+	}
+	expandBoundingBox(e) {
+		let { grid: t } = this;
+		if (t === void 0) return;
+		let n = t.boundingBox;
+		n.isEmpty || e.union(n.getBox());
+	}
+};
+//#endregion
+export { n as TerrainDomainObject };

package/dist/domains/terrain/TerrainRenderStyle.d.ts

@@ -0,0 +1,18 @@
+import { ColorType } from '../../foundation/domainObjectsHelpers/ColorType';
+import { RenderStyle } from '../../foundation/renderStyles/RenderStyle';
+import { ColorMapType } from '../../foundation/utilities/colors/ColorMapType';
+export declare class TerrainRenderStyle extends RenderStyle {
+    showContours: boolean;
+    contoursColorType: ColorType;
+    showSolid: boolean;
+    solidColorType: ColorType;
+    solidColorMapType: ColorMapType;
+    solidContourVolume: number;
+    solidContourUse: boolean;
+    solidShininess: number;
+    solidShininessUse: boolean;
+    solidOpacity: number;
+    solidOpacityUse: boolean;
+    increment: number;
+    clone(): RenderStyle;
+}