@cognite/reveal-components 1.0.0

package/dist/ui/hooks/scenes/sceneResponseTypeGuards.js

@@ -0,0 +1,90 @@
+import { PointColorType as e, PointShape as t } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/ui/hooks/scenes/sceneResponseTypeGuards.ts
+function n(e, t) {
+	return t.every(([t, n]) => n(e, t));
+}
+function r(e, t) {
+	return typeof e[t] == "number";
+}
+function i(e, t) {
+	return typeof e[t] == "string";
+}
+function a(e, t) {
+	return e[t] === void 0 || typeof e[t] == "number";
+}
+function o(e, t) {
+	return e[t] === void 0 || typeof e[t] == "string";
+}
+function s(e, t) {
+	return e[t] === void 0 || typeof e[t] == "boolean";
+}
+function c(s) {
+	if (typeof s != "object" || !s) return !1;
+	let c = s;
+	if (!n(c, [
+		["name", i],
+		["cameraTranslationX", r],
+		["cameraTranslationY", r],
+		["cameraTranslationZ", r],
+		["cameraEulerRotationX", r],
+		["cameraEulerRotationY", r],
+		["cameraEulerRotationZ", r]
+	]) || !n(c, [
+		["description", o],
+		["cameraTargetX", a],
+		["cameraTargetY", a],
+		["cameraTargetZ", a],
+		["cadBudget", a],
+		["pointCloudBudget", a],
+		["maxRenderResolution", a],
+		["movingCameraResolutionFactor", a],
+		["pointCloudPointSize", a]
+	])) return !1;
+	if (c.pointCloudPointShape !== void 0) {
+		let e = c.pointCloudPointShape;
+		if (typeof e != "string" || !(e in t)) return !1;
+	}
+	if (c.pointCloudColor !== void 0) {
+		let t = c.pointCloudColor;
+		if (typeof t != "string" || !(t in e)) return !1;
+	}
+	return !0;
+}
+function l(e) {
+	if (typeof e != "object" || !e) return !1;
+	let t = e;
+	return !d(t) || !n(t, [["revisionId", r]]) ? !1 : f(t);
+}
+function u(e) {
+	if (typeof e != "object" || !e) return !1;
+	let t = e;
+	return !d(t) || !n(t, [["image360CollectionExternalId", i], ["image360CollectionSpace", i]]) ? !1 : f(t);
+}
+function d(e) {
+	return n(e, [
+		["translationX", r],
+		["translationY", r],
+		["translationZ", r],
+		["eulerRotationX", r],
+		["eulerRotationY", r],
+		["eulerRotationZ", r],
+		["scaleX", r],
+		["scaleY", r],
+		["scaleZ", r]
+	]);
+}
+function f(e) {
+	return s(e, "defaultVisible");
+}
+function p(e) {
+	if (typeof e != "object" || !e) return !1;
+	let t = e;
+	return t?.properties?.scene?.["RevisionProperties/v1"] !== void 0 && l(t.properties.scene["RevisionProperties/v1"]);
+}
+function m(e) {
+	if (typeof e != "object" || !e) return !1;
+	let t = e;
+	return t?.properties?.scene?.["Image360CollectionProperties/v1"] !== void 0 && u(t.properties.scene["Image360CollectionProperties/v1"]);
+}
+//#endregion
+export { m as isScene360CollectionEdge, p as isScene3dModelEdge, c as isSceneConfigurationProperties };

package/dist/ui/hooks/scenes/types.d.ts

@@ -0,0 +1,197 @@
+import { NodeDefinition } from '@cognite/sdk';
+import { EdgeItem, NodeItem, DmsUniqueIdentifier, Space, ExternalId } from '../../../data-providers/FdmSDK';
+import { DMImage360AddOptions, Model3DAddOptions } from '../../../data-providers/types';
+import { SceneQualitySettings, GroundPlane, Skybox } from '../../components/SceneContainer/sceneTypes';
+export declare const SCENE_QUERY_LIMIT = 100;
+export declare const SCENE_RELATED_DATA_LIMIT = 10000;
+export type Transformation3d = {
+    translationX: number;
+    translationY: number;
+    translationZ: number;
+    eulerRotationX: number;
+    eulerRotationY: number;
+    eulerRotationZ: number;
+    scaleX: number;
+    scaleY: number;
+    scaleZ: number;
+};
+export type SceneData = {
+    name: string;
+    cameraTranslationX: number;
+    cameraTranslationY: number;
+    cameraTranslationZ: number;
+    cameraEulerRotationX: number;
+    cameraEulerRotationY: number;
+    cameraEulerRotationZ: number;
+    cameraTargetX?: number;
+    cameraTargetY?: number;
+    cameraTargetZ?: number;
+    updatedAt?: string;
+    modelOptions: Array<Model3DAddOptions>;
+    image360CollectionOptions: DMImage360AddOptions[];
+    groundPlanes: GroundPlane[];
+    skybox?: Skybox;
+    qualitySettings?: SceneQualitySettings;
+};
+export type SceneModelsProperties = Transformation3d & {
+    revisionId: number;
+};
+export type SceneConfigurationProperties = {
+    name: string;
+    skybox?: DmsUniqueIdentifier;
+    cameraTranslationX: number;
+    cameraTranslationY: number;
+    cameraTranslationZ: number;
+    cameraEulerRotationX: number;
+    cameraEulerRotationY: number;
+    cameraEulerRotationZ: number;
+    cameraTargetX?: number;
+    cameraTargetY?: number;
+    cameraTargetZ?: number;
+    updatedAt?: string;
+    cadBudget?: number;
+    pointCloudBudget?: number;
+    maxRenderResolution?: number;
+    movingCameraResolutionFactor?: number;
+    pointCloudPointSize?: number;
+    pointCloudPointShape?: string;
+    pointCloudColor?: string;
+    image360Transparency?: number;
+    image360MarkerAlpha?: number;
+    image360MarkerVisible?: boolean;
+    image360XRay?: boolean;
+};
+export type SkyboxProperties = {
+    label: string;
+    isSpherical: boolean;
+    file: string;
+};
+export type GroundPlaneProperties = {
+    file: string;
+    label: string;
+    wrapping: string;
+    repeatU?: number;
+    repeatV?: number;
+};
+export type Cdf3dRevisionProperties = Transformation3d & {
+    revisionId: number;
+    defaultVisible?: boolean;
+};
+export type Cdf3dImage360CollectionProperties = Transformation3d & {
+    image360CollectionExternalId: string;
+    image360CollectionSpace: string;
+    defaultVisible?: boolean;
+};
+export type SceneViewRef<ExternalId extends string, Space extends string = 'scene'> = {
+    readonly type: 'view';
+    readonly space: Space;
+    readonly externalId: ExternalId;
+    readonly version: 'v1';
+};
+export declare const SCENE_SOURCE: {
+    readonly type: "view";
+    readonly space: "scene";
+    readonly externalId: "SceneConfiguration";
+    readonly version: "v1";
+};
+export declare const TRANSFORMATION_SOURCE: {
+    readonly type: "view";
+    readonly space: "cdf_3d_schema";
+    readonly externalId: "Transformation3d";
+    readonly version: "v1";
+};
+export declare const ENVIRONMENT_MAP_SOURCE: {
+    readonly type: "view";
+    readonly space: "scene";
+    readonly externalId: "EnvironmentMap";
+    readonly version: "v1";
+};
+export declare const IMAGE_360_COLLECTION_SOURCE: {
+    readonly type: "view";
+    readonly space: "scene";
+    readonly externalId: "Image360CollectionProperties";
+    readonly version: "v1";
+};
+export declare const REVISION_SOURCE: {
+    readonly type: "view";
+    readonly space: "scene";
+    readonly externalId: "RevisionProperties";
+    readonly version: "v1";
+};
+export declare const GROUND_PLANE_SOURCE: {
+    readonly type: "view";
+    readonly space: "scene";
+    readonly externalId: "TexturedPlane";
+    readonly version: "v1";
+};
+export declare const groundPlaneSourceWithProperties: [
+    {
+        readonly source: SceneViewRef<'TexturedPlane'>;
+        readonly properties: ['file', 'label', 'wrapping', 'repeatU', 'repeatV'];
+    }
+];
+export declare const transformationSourceWithProperties: [
+    {
+        readonly source: SceneViewRef<'Transformation3d', 'cdf_3d_schema'>;
+        readonly properties: [
+            'translationX',
+            'translationY',
+            'translationZ',
+            'eulerRotationX',
+            'eulerRotationY',
+            'eulerRotationZ',
+            'scaleX',
+            'scaleY',
+            'scaleZ'
+        ];
+    }
+];
+export declare const sceneSourceWithProperties: [
+    {
+        readonly source: SceneViewRef<'SceneConfiguration'>;
+        readonly properties: ['*'];
+    }
+];
+export declare const revisionSourceWithProperties: [
+    {
+        readonly source: SceneViewRef<'RevisionProperties'>;
+        readonly properties: ['*'];
+    }
+];
+export declare const image360CollectionSourceWithProperties: [
+    {
+        readonly source: SceneViewRef<'Image360CollectionProperties'>;
+        readonly properties: ['*'];
+    }
+];
+export declare const environmentMapSourceWithProperties: [
+    {
+        readonly source: SceneViewRef<'EnvironmentMap'>;
+        readonly properties: ['label', 'file', 'isSpherical'];
+    }
+];
+export type ScenesMap = Record<Space, Record<ExternalId, SceneData>>;
+export type Use3dScenesResult<TData = ScenesMap> = {
+    data: TData | undefined;
+    isLoading: boolean;
+    isFetching: boolean;
+    isFetched: boolean;
+    error: Error | null;
+};
+type SceneConfigurationPropertiesOptional = Partial<SceneConfigurationProperties>;
+export type SceneNode = Omit<NodeDefinition, 'properties'> & {
+    properties: {
+        scene: {
+            'SceneConfiguration/v1': SceneConfigurationPropertiesOptional;
+        };
+    };
+};
+export type Use3dScenesQueryResult = {
+    scenes: SceneNode[];
+    sceneModels: Array<EdgeItem<Record<string, Record<string, Cdf3dRevisionProperties>>>>;
+    scene360Collections: Array<EdgeItem<Record<string, Record<string, Cdf3dImage360CollectionProperties>>>>;
+    sceneGroundPlanes: Array<NodeItem<GroundPlaneProperties>>;
+    sceneGroundPlaneEdges: Array<EdgeItem<Record<string, Record<string, Transformation3d>>>>;
+    sceneSkybox: Array<NodeItem<SkyboxProperties>>;
+};
+export {};

package/dist/ui/hooks/scenes/types.js

@@ -0,0 +1,72 @@
+//#region libs/shared/reveal-components/src/ui/hooks/scenes/types.ts
+var e = 1e4, t = {
+	type: "view",
+	space: "scene",
+	externalId: "SceneConfiguration",
+	version: "v1"
+}, n = {
+	type: "view",
+	space: "cdf_3d_schema",
+	externalId: "Transformation3d",
+	version: "v1"
+}, r = {
+	type: "view",
+	space: "scene",
+	externalId: "EnvironmentMap",
+	version: "v1"
+}, i = {
+	type: "view",
+	space: "scene",
+	externalId: "Image360CollectionProperties",
+	version: "v1"
+}, a = {
+	type: "view",
+	space: "scene",
+	externalId: "RevisionProperties",
+	version: "v1"
+}, o = {
+	type: "view",
+	space: "scene",
+	externalId: "TexturedPlane",
+	version: "v1"
+}, s = [{
+	source: o,
+	properties: [
+		"file",
+		"label",
+		"wrapping",
+		"repeatU",
+		"repeatV"
+	]
+}], c = [{
+	source: n,
+	properties: [
+		"translationX",
+		"translationY",
+		"translationZ",
+		"eulerRotationX",
+		"eulerRotationY",
+		"eulerRotationZ",
+		"scaleX",
+		"scaleY",
+		"scaleZ"
+	]
+}], l = [{
+	source: t,
+	properties: ["*"]
+}], u = [{
+	source: a,
+	properties: ["*"]
+}], d = [{
+	source: i,
+	properties: ["*"]
+}], f = [{
+	source: r,
+	properties: [
+		"label",
+		"file",
+		"isSpherical"
+	]
+}];
+//#endregion
+export { r as ENVIRONMENT_MAP_SOURCE, o as GROUND_PLANE_SOURCE, i as IMAGE_360_COLLECTION_SOURCE, a as REVISION_SOURCE, e as SCENE_RELATED_DATA_LIMIT, t as SCENE_SOURCE, n as TRANSFORMATION_SOURCE, f as environmentMapSourceWithProperties, s as groundPlaneSourceWithProperties, d as image360CollectionSourceWithProperties, u as revisionSourceWithProperties, l as sceneSourceWithProperties, c as transformationSourceWithProperties };

package/dist/ui/hooks/scenes/use3dScene.context.d.ts

@@ -0,0 +1,13 @@
+import { Context } from 'react';
+import { SceneData, ScenesMap } from './types';
+export type Use3dSceneDependencies = {
+    use3dScenes: (select: (scenes: ScenesMap) => SceneData | undefined, options?: {
+        enabled?: boolean;
+    }) => {
+        data: SceneData | undefined;
+        isFetched: boolean;
+        error: Error | null;
+    };
+};
+export declare const defaultUse3dSceneDependencies: Use3dSceneDependencies;
+export declare const Use3dSceneContext: Context<Use3dSceneDependencies>;

package/dist/ui/hooks/scenes/use3dScene.context.js

@@ -0,0 +1,12 @@
+import { use3dScenes as e } from "./use3dScenes.js";
+import { createContext as t } from "react";
+var n = { use3dScenes: (t, n) => {
+	let { data: r, isFetched: i, error: a } = e(void 0, t, n);
+	return {
+		data: r,
+		isFetched: i,
+		error: a
+	};
+} }, r = t(n);
+//#endregion
+export { r as Use3dSceneContext, n as defaultUse3dSceneDependencies };

package/dist/ui/hooks/scenes/use3dScene.d.ts

@@ -0,0 +1,9 @@
+import { SceneData, ScenesMap } from './types';
+export type Use3dSceneResult = {
+    data: SceneData | undefined;
+    isFetched: boolean;
+    error: Error | null;
+    isError: boolean;
+};
+export declare function use3dScene(sceneExternalId: string | undefined, sceneSpace: string | undefined): Use3dSceneResult;
+export declare function select3dSceneData(scenesMap: ScenesMap | undefined, sceneSpace: string | undefined, sceneExternalId: string | undefined): SceneData | undefined;

package/dist/ui/hooks/scenes/use3dScene.js

@@ -0,0 +1,30 @@
+import { Use3dSceneContext as e } from "./use3dScene.context.js";
+import { useCallback as t, useContext as n } from "react";
+//#region libs/shared/reveal-components/src/ui/hooks/scenes/use3dScene.ts
+function r(r, o) {
+	let { use3dScenes: s } = n(e), c = !!(r && o), { data: l, isFetched: u, error: d } = s(t((e) => i(e, o, r), [o, r]), { enabled: c });
+	if (!r || !o) return {
+		data: void 0,
+		isFetched: !1,
+		error: null,
+		isError: !1
+	};
+	let f = a({
+		isFetched: u,
+		error: d
+	}, l);
+	return {
+		data: l,
+		isFetched: u,
+		error: f,
+		isError: f !== null
+	};
+}
+function i(e, t, n) {
+	if (!(!n || !t)) return e?.[t]?.[n];
+}
+function a(e, t) {
+	return e.error === null ? e.isFetched && t === void 0 ? /* @__PURE__ */ Error("Scene configuration is undefined") : null : e.error;
+}
+//#endregion
+export { i as select3dSceneData, r as use3dScene };

package/dist/ui/hooks/scenes/use3dScenes.context.d.ts

@@ -0,0 +1,15 @@
+import { Context } from 'react';
+import { CogniteClient } from '@cognite/sdk';
+import { FdmSDK } from '../../../data-providers/FdmSDK';
+import { getRevisionExternalIdsAndSpaces } from '../network/getRevisionExternalIdAndSpace';
+import { hasSceneDataModel } from './hasSceneDataModel';
+export type Use3dScenesDependencies = {
+    useSDK: (userSdk?: CogniteClient) => CogniteClient;
+    createFdmSdk: (sdk: CogniteClient) => FdmSDK;
+    sceneLimit: number;
+    sceneRelatedDataLimit: number;
+    hasSceneDataModel: typeof hasSceneDataModel;
+    getRevisionExternalIdsAndSpaces: typeof getRevisionExternalIdsAndSpaces;
+};
+export declare const defaultUse3dScenesDependencies: Use3dScenesDependencies;
+export declare const Use3dScenesContext: Context<Use3dScenesDependencies>;

package/dist/ui/hooks/scenes/use3dScenes.context.js

@@ -0,0 +1,17 @@
+import { FdmSDK as e } from "../../../data-providers/FdmSDK.js";
+import { SCENE_RELATED_DATA_LIMIT as t } from "./types.js";
+import { getRevisionExternalIdsAndSpaces as n } from "../network/getRevisionExternalIdAndSpace.js";
+import { useSDK as r } from "../../components/RevealCanvas/SDKProvider.js";
+import { hasSceneDataModel as i } from "./hasSceneDataModel.js";
+import { createContext as a } from "react";
+//#region libs/shared/reveal-components/src/ui/hooks/scenes/use3dScenes.context.ts
+var o = {
+	useSDK: r,
+	createFdmSdk: (t) => new e(t),
+	sceneLimit: 100,
+	sceneRelatedDataLimit: t,
+	hasSceneDataModel: i,
+	getRevisionExternalIdsAndSpaces: n
+}, s = a(o);
+//#endregion
+export { s as Use3dScenesContext, o as defaultUse3dScenesDependencies };

package/dist/ui/hooks/scenes/use3dScenes.d.ts

@@ -0,0 +1,5 @@
+import { CogniteClient } from '@cognite/sdk';
+import { Use3dScenesResult, ScenesMap } from './types';
+export declare function use3dScenes<TSelected = ScenesMap>(userSdk?: CogniteClient, select?: (scenes: ScenesMap) => TSelected, options?: {
+    enabled?: boolean;
+}): Use3dScenesResult<TSelected>;

package/dist/ui/hooks/scenes/use3dScenes.js

@@ -0,0 +1,162 @@
+import { createDmsQueryDataAccumulator as e } from "../../../utilities/dms-cursoring/dmsAccumulator.js";
+import { queryKeys as t } from "../../../utilities/queryKeys.js";
+import { isScene360CollectionEdge as n, isScene3dModelEdge as r } from "./sceneResponseTypeGuards.js";
+import { isCog3dModelExternalId as i, tryGetModelIdFromExternalId as a } from "../../../utilities/tryGetModelIdFromExternalId.js";
+import { createGetScenesQuery as o } from "./allScenesQuery.js";
+import { Use3dScenesContext as s } from "./use3dScenes.context.js";
+import { useContext as c, useMemo as l } from "react";
+import { useQuery as u } from "@tanstack/react-query";
+import { Euler as d, MathUtils as f, Matrix4 as p } from "three";
+import { CDF_TO_VIEWER_TRANSFORMATION as m } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/ui/hooks/scenes/use3dScenes.tsx
+function h(i, d, f) {
+	let { useSDK: p, createFdmSdk: m, sceneLimit: h, sceneRelatedDataLimit: v, hasSceneDataModel: x, getRevisionExternalIdsAndSpaces: S } = c(s), C = p(i), w = l(() => m(C), [m, C]), { data: T, isLoading: E, isFetching: D, isFetched: O, error: k } = u({
+		queryKey: t.scenes(),
+		queryFn: async () => {
+			if (!await x(C)) return {};
+			let t = o(h, v, {}), i = await e(w, t, { serial: ["scenes", { parallel: [
+				"sceneModels",
+				"scene360Collections",
+				"sceneSkybox",
+				"sceneGroundPlaneEdges"
+			] }] }).accumulateAllData(), s = g(i.items.scenes, i.items.sceneSkybox);
+			return await _(i.items.sceneModels.filter(r), s, a, w, S), y(i.items.scene360Collections.filter(n), s), b(i.items.sceneGroundPlanes, i.items.sceneGroundPlaneEdges, s), s;
+		},
+		select: d,
+		enabled: f?.enabled,
+		staleTime: Infinity
+	});
+	return {
+		data: T,
+		isLoading: E,
+		isFetching: D,
+		isFetched: O,
+		error: k
+	};
+}
+function g(e, t) {
+	return e.reduce((e, n) => {
+		let { space: r, externalId: i } = n;
+		if (e[r] === void 0 && (e[r] = {}), e[r][i] === void 0) {
+			let a = n.properties.scene["SceneConfiguration/v1"], o, s = a.skybox;
+			if (s !== void 0) {
+				let e = t.find((e) => e.externalId === s.externalId && e.space === s.space);
+				e !== void 0 && (o = Object.values(Object.values(e.properties)[0])[0]);
+			}
+			e[r][i] = {
+				name: a.name ?? "",
+				cameraTranslationX: a.cameraTranslationX ?? 0,
+				cameraTranslationY: a.cameraTranslationY ?? 0,
+				cameraTranslationZ: a.cameraTranslationZ ?? 0,
+				cameraEulerRotationX: a.cameraEulerRotationX ?? 0,
+				cameraEulerRotationY: a.cameraEulerRotationY ?? 0,
+				cameraEulerRotationZ: a.cameraEulerRotationZ ?? 0,
+				cameraTargetX: a.cameraTargetX,
+				cameraTargetY: a.cameraTargetY,
+				cameraTargetZ: a.cameraTargetZ,
+				updatedAt: a.updatedAt,
+				modelOptions: [],
+				image360CollectionOptions: [],
+				groundPlanes: [],
+				skybox: o,
+				qualitySettings: {
+					cadBudget: a.cadBudget,
+					pointCloudBudget: a.pointCloudBudget,
+					maxRenderResolution: a.maxRenderResolution,
+					movingCameraResolutionFactor: a.movingCameraResolutionFactor,
+					pointCloudPointSize: a.pointCloudPointSize,
+					pointCloudPointShape: a.pointCloudPointShape,
+					pointCloudColor: a.pointCloudColor,
+					image360Transparency: a.image360Transparency,
+					image360MarkerAlpha: a.image360MarkerAlpha,
+					image360MarkerVisible: a.image360MarkerVisible,
+					image360XRay: a.image360XRay
+				}
+			};
+		}
+		return e;
+	}, {});
+}
+async function _(e, t, n, r, a) {
+	let o = e.map(v), s = [], c = e.flatMap((e, t) => i(e.endNode.externalId) ? (s.push(t), [{
+		modelExternalId: e.endNode.externalId,
+		revisionId: Number(o[t]?.revisionId)
+	}]) : []), l = c.length > 0 ? await a(c, r) : [], u = [];
+	l.forEach((e, t) => {
+		u[s[t]] = e;
+	}), e.forEach((e, r) => {
+		let { space: i, externalId: a } = e.startNode, s = o[r], c = u[r];
+		if (t[i]?.[a] === void 0 || s === void 0) return;
+		let l = x(s);
+		if (c !== void 0) {
+			let e = {
+				modelCategory: "model3d",
+				sourceType: "cdm",
+				externalId: c.revisionExternalId,
+				space: c.revisionSpace,
+				transform: l,
+				defaultVisible: s.defaultVisible
+			};
+			t[i]?.[a].modelOptions.push(e);
+			return;
+		}
+		let d = n(e.endNode.externalId), f = Number(s.revisionId);
+		if (d === void 0 || !Number.isInteger(f)) return;
+		let p = {
+			modelCategory: "model3d",
+			sourceType: "classic",
+			modelId: d,
+			revisionId: f,
+			transform: l,
+			defaultVisible: s.defaultVisible
+		};
+		t[i]?.[a].modelOptions.push(p);
+	});
+}
+function v(e) {
+	let t = Object.values(e.properties)[0];
+	return t ? Object.values(t)[0] : void 0;
+}
+function y(e, t) {
+	e.forEach((e) => {
+		let { space: n, externalId: r } = e.startNode;
+		if (t[n]?.[r] === void 0) return;
+		let i = Object.values(Object.values(e.properties)[0])[0], a = x(i), o = {
+			modelCategory: "image360",
+			sourceType: "dm",
+			externalId: i.image360CollectionExternalId,
+			space: i.image360CollectionSpace,
+			transform: a,
+			defaultVisible: i.defaultVisible
+		};
+		t[n]?.[r].image360CollectionOptions.push(o);
+	});
+}
+function b(e, t, n) {
+	t.forEach((t) => {
+		let { space: r, externalId: i } = t.startNode, a = e.find((e) => e.externalId === t.endNode.externalId && e.space === t.endNode.space);
+		if (n[r]?.[i] === void 0 || a === void 0) return;
+		let o = Object.values(Object.values(t.properties)[0])[0], s = Object.values(Object.values(a.properties)[0])[0], c = {
+			label: s.label,
+			file: s.file,
+			wrapping: s.wrapping,
+			repeatU: s.repeatU ?? 1,
+			repeatV: s.repeatV ?? 1,
+			...o
+		};
+		n[r]?.[i].groundPlanes.push(c);
+	});
+}
+function x(e) {
+	let t = new p();
+	t.makeRotationFromEuler(new d(f.degToRad(e.eulerRotationX), f.degToRad(e.eulerRotationY), f.degToRad(e.eulerRotationZ))), S(e);
+	let n = new p().makeScale(e.scaleX, e.scaleY, e.scaleZ);
+	t.multiply(n);
+	let r = new p().makeTranslation(e.translationX, e.translationY, e.translationZ);
+	return t.premultiply(r), t.premultiply(m), t;
+}
+function S(e) {
+	return e.scaleX === 0 && (e.scaleX = 1), e.scaleY === 0 && (e.scaleY = 1), e.scaleZ === 0 && (e.scaleZ = 1), e;
+}
+//#endregion
+export { h as use3dScenes };

package/dist/ui/hooks/scenes/useSceneConfig.context.d.ts

@@ -0,0 +1,7 @@
+import { Context } from 'react';
+import { use3dScene } from './use3dScene';
+export type UseSceneConfigDependencies = {
+    use3dScene: typeof use3dScene;
+};
+export declare const defaultUseSceneConfigDependencies: UseSceneConfigDependencies;
+export declare const UseSceneConfigContext: Context<UseSceneConfigDependencies>;

package/dist/ui/hooks/scenes/useSceneConfig.context.js

@@ -0,0 +1,6 @@
+import { use3dScene as e } from "./use3dScene.js";
+import { createContext as t } from "react";
+//#region libs/shared/reveal-components/src/ui/hooks/scenes/useSceneConfig.context.ts
+var n = { use3dScene: e }, r = t(n);
+//#endregion
+export { r as UseSceneConfigContext, n as defaultUseSceneConfigDependencies };

package/dist/ui/hooks/scenes/useSceneConfig.d.ts

@@ -0,0 +1,8 @@
+import { Scene } from '../../components/SceneContainer/sceneTypes';
+export type UseSceneConfigResult = {
+    data: Scene | undefined;
+    isFetched: boolean;
+    error: Error | null;
+    isError: boolean;
+};
+export declare const useSceneConfig: (sceneExternalId: string | undefined, sceneSpace: string | undefined) => UseSceneConfigResult;