@cognite/reveal-components 1.0.0

package/dist/foundation/utilities/translation/translateUtils.d.ts

@@ -0,0 +1,4 @@
+import { TranslationInput } from './TranslateInput';
+export declare function translateIfExists(input: TranslationInput | undefined): string | undefined;
+export declare function translate(input: TranslationInput): string;
+export declare function setCurrentLanguage(newLanguage: string | undefined): Promise<void>;

package/dist/foundation/utilities/translation/translateUtils.js

@@ -0,0 +1,52 @@
+import e from "../../../_virtual/_rolldown_dynamic_import_helper.js";
+import t from "../../../common/i18n/en/reveal-components.js";
+import { isTranslatedString as n } from "./TranslateInput.js";
+import { getLanguage as r } from "../../../ui/components/i18n/utils.js";
+//#region libs/shared/reveal-components/src/foundation/utilities/translation/translateUtils.ts
+var i = "en", a = i, o = t;
+u();
+function s(e) {
+	return e === void 0 ? void 0 : c(e);
+}
+function c(e) {
+	return n(e) ? d(e.key) : e.untranslated;
+}
+async function l(e) {
+	if (e === i && o === t) {
+		a = e;
+		return;
+	}
+	if (e !== void 0 && e !== a) try {
+		o = await f(e), a = e;
+	} catch {
+		console.warn("Error loading translation file");
+	}
+}
+async function u() {
+	let e = async () => {
+		await l(r());
+	};
+	window.addEventListener("languagechange", e), await e();
+}
+function d(e) {
+	return o !== void 0 && o[e] !== void 0 ? o[e] : t[e];
+}
+async function f(t) {
+	return (await e(/* #__PURE__ */ Object.assign({
+		"../../../common/i18n/de/reveal-components.json": () => import("../../../common/i18n/de/reveal-components.js"),
+		"../../../common/i18n/en/reveal-components.json": () => import("../../../common/i18n/en/reveal-components.js"),
+		"../../../common/i18n/es/reveal-components.json": () => import("../../../common/i18n/es/reveal-components.js"),
+		"../../../common/i18n/fr/reveal-components.json": () => import("../../../common/i18n/fr/reveal-components.js"),
+		"../../../common/i18n/it/reveal-components.json": () => import("../../../common/i18n/it/reveal-components.js"),
+		"../../../common/i18n/ja/reveal-components.json": () => import("../../../common/i18n/ja/reveal-components.js"),
+		"../../../common/i18n/ko/reveal-components.json": () => import("../../../common/i18n/ko/reveal-components.js"),
+		"../../../common/i18n/lv/reveal-components.json": () => import("../../../common/i18n/lv/reveal-components.js"),
+		"../../../common/i18n/nb/reveal-components.json": () => import("../../../common/i18n/nb/reveal-components.js"),
+		"../../../common/i18n/nl/reveal-components.json": () => import("../../../common/i18n/nl/reveal-components.js"),
+		"../../../common/i18n/pt/reveal-components.json": () => import("../../../common/i18n/pt/reveal-components.js"),
+		"../../../common/i18n/sv/reveal-components.json": () => import("../../../common/i18n/sv/reveal-components.js"),
+		"../../../common/i18n/zh/reveal-components.json": () => import("../../../common/i18n/zh/reveal-components.js")
+	}), `../../../common/i18n/${t}/reveal-components.json`, 7)).default;
+}
+//#endregion
+export { l as setCurrentLanguage, c as translate, s as translateIfExists };

package/dist/foundation/utilities/types.d.ts

@@ -0,0 +1,16 @@
+export type IconName = string | undefined;
+export type IconColor = string | undefined;
+export type ButtonType = 'default' | 'ghost' | 'ghost-destructive' | 'primary' | 'secondary' | 'tertiary';
+export type UniqueId = string;
+export declare enum CheckboxState {
+    All = 0,
+    Some = 1,
+    None = 2
+}
+export type PanelPosition = {
+    x: number;
+    y: number;
+    initialized?: boolean;
+};
+export declare function generateUniqueId(): UniqueId;
+export type TrackingDelegate<T extends Record<string, unknown> = Record<string, unknown>> = (eventName: string, eventCategory?: string, payload?: T) => void;

package/dist/foundation/utilities/types.js

@@ -0,0 +1,9 @@
+//#region libs/shared/reveal-components/src/foundation/utilities/types.ts
+var e = /* @__PURE__ */ function(e) {
+	return e[e.All = 0] = "All", e[e.Some = 1] = "Some", e[e.None = 2] = "None", e;
+}({});
+function t() {
+	return crypto.randomUUID();
+}
+//#endregion
+export { e as CheckboxState, t as generateUniqueId };

package/dist/foundation/views/BaseView.d.ts

@@ -0,0 +1,59 @@
+import { DomainObject } from '../domainObjects/DomainObject';
+import { DomainObjectChange } from '../domainObjectsHelpers/DomainObjectChange';
+import { UnitSystem } from '../renderTarget/UnitSystem';
+/**
+ * Represents the observer in the Observer pattern
+ * It provides common functionality for all types of views.
+ */
+export declare abstract class BaseView<DomainObjectType extends DomainObject = DomainObject> {
+    private _domainObject;
+    protected get hasDomainObject(): boolean;
+    get domainObject(): DomainObjectType;
+    /**
+     * Initializes the view.
+     * Override this function to initialize your view.
+     * @remarks
+     * Always call `super.initialize()` in the overrides.
+     */
+    initialize(): void;
+    /**
+     * Updates the view with the given change.
+     * Override this function to update your view.
+     *
+     * @param change - The domain object change to apply to the view.
+     * @remarks
+     * Always call `super.update()` in the overrides.
+     */
+    update(_change: DomainObjectChange): void;
+    /**
+     * Clears the memory and removes redundant data.
+     * This method should be overridden in derived classes.
+     * @remarks
+     * Always call `super.clearMemory()` in the overrides.
+     */
+    clearMemory(): void;
+    /**
+     * Called when the view is set to be visible.
+     * Override this function to perform any necessary actions when the view becomes visible.
+     * @remarks
+     * Always call `super.onShow()` in the overrides.
+     */
+    onShow(): void;
+    /**
+     * Called when the view is set to NOT visible.
+     * Override this function to perform any necessary actions when the view is hidden.
+     * @remarks
+     * Always call `super.onHide()` in the overrides.
+     */
+    onHide(): void;
+    /**
+     * Dispose the view.
+     * Override this function to perform any necessary cleanup when the view is set to NOT visible.
+     * This method is called just before the view is removed from the view list and detached.
+     * @remarks
+     * Always call `super.dispose()` in the overrides.
+     */
+    dispose(): void;
+    setDomainObject(domainObject: DomainObjectType): void;
+    protected getUnitSystem(): UnitSystem;
+}

package/dist/foundation/views/BaseView.js

@@ -0,0 +1,29 @@
+import { getRoot as e } from "../domainObjects/getRoot.js";
+import { UNDEFINED_UNIT_SYSTEM as t } from "../renderTarget/UnitSystem.js";
+//#region libs/shared/reveal-components/src/foundation/views/BaseView.ts
+var n = class {
+	_domainObject = void 0;
+	get hasDomainObject() {
+		return this._domainObject !== void 0;
+	}
+	get domainObject() {
+		if (this._domainObject === void 0) throw Error("The DomainObject is missing in the view");
+		return this._domainObject;
+	}
+	initialize() {}
+	update(e) {}
+	clearMemory() {}
+	onShow() {}
+	onHide() {}
+	dispose() {
+		this._domainObject = void 0;
+	}
+	setDomainObject(e) {
+		this._domainObject = e;
+	}
+	getUnitSystem() {
+		return e(this.domainObject)?.unitSystem ?? t;
+	}
+};
+//#endregion
+export { n as BaseView };

package/dist/foundation/views/GroupThreeView.d.ts

@@ -0,0 +1,66 @@
+import { Box3, Group, Object3D } from 'three';
+import { CustomObjectIntersectInput, CustomObjectIntersection, ICustomObject } from '@cognite/reveal';
+import { DomainObject } from '../domainObjects/DomainObject';
+import { DomainObjectChange } from '../domainObjectsHelpers/DomainObjectChange';
+import { ThreeView } from './ThreeView';
+/**
+ * Represents an abstract class for a Three.js view that renders an Object3D.
+ * This class extends the ThreeView class. It created a group object3D and adds children to it.
+ * @remarks
+ * You only have to override addChildren() to create the object3D to be added to the group.
+ * Other methods you may override is:
+ * - intersectIfCloser() to determine the exact intersection point.
+ * - calculateBoundingBox() to calculate the bounding box if you don not relay on three.js.
+ */
+export declare abstract class GroupThreeView<DomainObjectType extends DomainObject = DomainObject> extends ThreeView<DomainObjectType> implements ICustomObject {
+    protected readonly _group: Group;
+    private _inNeedsUpdate;
+    protected get isEmpty(): boolean;
+    get object(): Object3D;
+    get shouldPick(): boolean;
+    get shouldPickBoundingBox(): boolean;
+    get isPartOfBoundingBox(): boolean;
+    get useDepthTest(): boolean;
+    getBoundingBox(target: Box3): Box3;
+    intersectIfCloser(intersectInput: CustomObjectIntersectInput, closestDistance: number | undefined): undefined | CustomObjectIntersection;
+    initialize(): void;
+    update(change: DomainObjectChange): void;
+    clearMemory(): void;
+    dispose(): void;
+    /**
+     * Calculates the bounding box of the object.
+     * Overrides this if you want to calculate the bounding box in a
+     * different way that three.js does it. For instance if you don't
+     * want to include text labels in the bounding box.
+     *
+     * @returns The calculated bounding box.
+     */
+    protected calculateBoundingBox(): Box3;
+    /**
+     * Add the Object3 children to the view. Use the addChild() method to add the children.
+     * This method should always be overridden in derived classes.
+     */
+    protected abstract addChildren(): void;
+    /**
+     * Determines whether the view needs to be updated just before rendering.
+     * Typically needed to be implemented if the update function is not enough and
+     * the view depend on other factors as the model bounding box or the camera position.
+     * This method can be overridden in derived classes.
+     *
+     * When it returns true, the view will be rebuild by addChildren().
+     * @returns A boolean value indicating whether the view needs to be updated.
+     */
+    protected needsUpdateCore(): boolean;
+    /**
+     * Rebuilds children when they are missing or stale.
+     * The `object` getter calls this lazily; call it directly when the group
+     * must exist before the next `object` access (for example same-turn updates).
+     */
+    protected ensureChildren(): void;
+    protected get needsUpdate(): boolean;
+    private makeChildren;
+    protected removeChildren(): void;
+    protected addChild(child: Object3D | undefined): void;
+    protected removeChild(child: Object3D | undefined): void;
+    protected intersectObjectIfCloser(object: Object3D, intersectInput: CustomObjectIntersectInput, closestDistance: number | undefined): undefined | CustomObjectIntersection;
+}

package/dist/foundation/views/GroupThreeView.js

@@ -0,0 +1,103 @@
+import { Changes as e } from "../domainObjectsHelpers/Changes.js";
+import { ThreeView as t } from "./ThreeView.js";
+import { VisualDomainObject as n } from "../domainObjects/VisualDomainObject.js";
+import { Box3 as r, Group as i, Mesh as a } from "three";
+//#region libs/shared/reveal-components/src/foundation/views/GroupThreeView.ts
+var o = class extends t {
+	_group = new i();
+	_inNeedsUpdate = !1;
+	get isEmpty() {
+		return this._group.children.length === 0;
+	}
+	get object() {
+		return this.ensureChildren(), this._group;
+	}
+	get shouldPick() {
+		return !0;
+	}
+	get shouldPickBoundingBox() {
+		return !0;
+	}
+	get isPartOfBoundingBox() {
+		return !0;
+	}
+	get useDepthTest() {
+		return !0;
+	}
+	getBoundingBox(e) {
+		return e.copy(this.boundingBox), e;
+	}
+	intersectIfCloser(e, t) {
+		return this.intersectObjectIfCloser(this.object, e, t);
+	}
+	initialize() {
+		super.initialize(), this.ensureChildren(), this.renderTarget.addCustomObject(this);
+	}
+	update(t) {
+		super.update(t), t.isChanged(e.geometry, e.dragging) && (this.removeChildren(), this.invalidateRenderTarget());
+	}
+	clearMemory() {
+		super.clearMemory(), this.removeChildren();
+	}
+	dispose() {
+		this.removeChildren(), this.renderTarget.removeCustomObject(this), super.dispose();
+	}
+	calculateBoundingBox() {
+		if (this.object === void 0) return new r().makeEmpty();
+		let e = new r();
+		return e.setFromObject(this.object, !0), e;
+	}
+	needsUpdateCore() {
+		return !1;
+	}
+	ensureChildren() {
+		this.needsUpdate && this.removeChildren(), this.isEmpty && this.makeChildren();
+	}
+	get needsUpdate() {
+		if (this._inNeedsUpdate) return !1;
+		this._inNeedsUpdate = !0;
+		let e = this.needsUpdateCore();
+		return this._inNeedsUpdate = !1, e;
+	}
+	makeChildren() {
+		if (!this.isEmpty) throw Error("Can make the object when it is already made");
+		this.addChildren();
+	}
+	removeChildren() {
+		this.isEmpty || (s(this._group), this._group.remove(...this._group.children));
+	}
+	addChild(e) {
+		e !== void 0 && this._group.add(e);
+	}
+	removeChild(e) {
+		e !== void 0 && (s(e), this._group.remove(e));
+	}
+	intersectObjectIfCloser(e, t, r) {
+		let i = t.raycaster.intersectObject(e, !0);
+		if (i === void 0 || i.length === 0) return;
+		let { point: a, distance: o } = i[0];
+		if (r !== void 0 && r < o) return;
+		let { domainObject: s } = this;
+		if (s instanceof n) {
+			if (s.hasClippingInIntersection && !t.isVisible(a)) return;
+		} else if (!t.isVisible(a)) return;
+		let c = {
+			type: "customObject",
+			point: a,
+			distanceToCamera: o,
+			userData: i[0],
+			customObject: this,
+			domainObject: s
+		};
+		return this.shouldPickBoundingBox && (this.boundingBox.isEmpty() || (c.boundingBox = this.boundingBox)), c;
+	}
+};
+function s(e) {
+	if (e === void 0) return;
+	if (e instanceof i) for (let t of e.children) s(t);
+	if (!(e instanceof a)) return;
+	let t = e.material;
+	t != null && (t.texture?.dispose(), t.dispose());
+}
+//#endregion
+export { o as GroupThreeView };

package/dist/foundation/views/ThreeView.d.ts

@@ -0,0 +1,44 @@
+import { PerspectiveCamera, Box3 } from 'three';
+import { DomainObject } from '../domainObjects/DomainObject';
+import { DomainObjectChange } from '../domainObjectsHelpers/DomainObjectChange';
+import { RenderStyle } from '../renderStyles/RenderStyle';
+import { RenderTarget } from '../renderTarget/RenderTarget';
+import { BaseView } from './BaseView';
+/**
+ * Represents an abstract base class for a Three.js view in the application.
+ * Extends the `BaseView` class. It only has the pointer to the renderTarget and a bounding box.
+ * Inherit from this class if you want some visualization that do dot require a group object3D as the root object.
+ * It can for instance be a view that changes something on another view, dor instance texture on a surface or whatever.
+ * I just wanted to make it ready for some corner cases I have seen during a long time as 3D developer.
+ */
+export declare abstract class ThreeView<DomainObjectType extends DomainObject = DomainObject> extends BaseView<DomainObjectType> {
+    private _boundingBox;
+    private _renderTarget;
+    get hasRenderTarget(): boolean;
+    get renderTarget(): RenderTarget;
+    protected get style(): RenderStyle | undefined;
+    update(change: DomainObjectChange): void;
+    clearMemory(): void;
+    onShow(): void;
+    onHide(): void;
+    dispose(): void;
+    /**
+     * Calculates the bounding box of the view.
+     * Override this function to recalculate the bounding box of the view.
+     * @returns The calculated bounding box of the view.
+     */
+    protected abstract calculateBoundingBox(): Box3;
+    /**
+     * This method is called before rendering the view.
+     * Override this function to perform any necessary operations
+     * just before rendering. Have in mind that the Object3D are build at the time this is
+     * called, so you can only do adjustment on existing object3D's.
+     * @remarks
+     * Always call `super.beforeRender(camera)` in the overrides.
+     */
+    beforeRender(_camera: PerspectiveCamera): void;
+    get boundingBox(): Box3;
+    protected invalidateBoundingBox(): void;
+    attach(domainObject: DomainObjectType, renderTarget: RenderTarget): void;
+    protected invalidateRenderTarget(): void;
+}

package/dist/foundation/views/ThreeView.js

@@ -0,0 +1,47 @@
+import { Changes as e } from "../domainObjectsHelpers/Changes.js";
+import { BaseView as t } from "./BaseView.js";
+//#region libs/shared/reveal-components/src/foundation/views/ThreeView.ts
+var n = class extends t {
+	_boundingBox = void 0;
+	_renderTarget = void 0;
+	get hasRenderTarget() {
+		return this._renderTarget !== void 0;
+	}
+	get renderTarget() {
+		if (this._renderTarget === void 0) throw Error("The RenderTarget is missing in the view");
+		return this._renderTarget;
+	}
+	get style() {
+		return this.domainObject.getRenderStyle();
+	}
+	update(t) {
+		super.update(t), t.isChanged(e.geometry, e.dragging) && (this.invalidateBoundingBox(), this.invalidateRenderTarget());
+	}
+	clearMemory() {
+		super.clearMemory(), this.invalidateBoundingBox();
+	}
+	onShow() {
+		super.onShow(), this.invalidateRenderTarget();
+	}
+	onHide() {
+		super.onHide(), this.invalidateRenderTarget();
+	}
+	dispose() {
+		super.dispose(), this._renderTarget = void 0;
+	}
+	beforeRender(e) {}
+	get boundingBox() {
+		return this._boundingBox === void 0 && (this._boundingBox = this.calculateBoundingBox()), this._boundingBox;
+	}
+	invalidateBoundingBox() {
+		this._boundingBox = void 0;
+	}
+	attach(e, t) {
+		super.setDomainObject(e), this._renderTarget = t;
+	}
+	invalidateRenderTarget() {
+		this.renderTarget.invalidate();
+	}
+};
+//#endregion
+export { n as ThreeView };

package/dist/foundation/views/ThreeViewFactory.d.ts

@@ -0,0 +1,34 @@
+import { DomainObject } from '../domainObjects/DomainObject';
+import { Class } from '../domainObjectsHelpers/Class';
+import { ThreeView } from './ThreeView';
+type ThreeViewCreator = () => ThreeView;
+/**
+ * Determines if a Three.js view can be created for the given domain object.
+ *
+ * @param domainObject - The domain object to check.
+ * @returns `true` if a Three.js view can be created, otherwise `false`.
+ */
+export declare function canCreateThreeView(domainObject: DomainObject): boolean;
+/**
+ * Creates a ThreeView instance for the given domain object.
+ *
+ * @param domainObject - The domain object for which the ThreeView is to be created.
+ * @returns A ThreeView instance if creation is successful, otherwise undefined.
+ */
+export declare function createThreeView(domainObject: DomainObject): ThreeView | undefined;
+/**
+ * Installs a Three.js view for a specific domain object type.
+ *
+ * @param domainObjectType - The class of the domain object for which the view is being installed.
+ * @param viewType - The class of the view to be installed.
+ */
+export declare function installThreeView<View extends ThreeView>(domainObjectType: Class<DomainObject>, ViewType: new () => View): void;
+/**
+ * Installs a Three.js view creator for a specific domain object type.
+ *
+ * @param domainObjectType - The class of the domain object for which the view creator is being installed.
+ * @param creator - The view creator to be installed.
+ */
+export declare function installThreeViewCreator(domainObjectType: Class<DomainObject>, creator: ThreeViewCreator): void;
+export declare function getClassesOf(domainObject: DomainObject): Generator<Class<DomainObject>>;
+export {};

package/dist/foundation/views/ThreeViewFactory.js

@@ -0,0 +1,35 @@
+//#region libs/shared/reveal-components/src/foundation/views/ThreeViewFactory.ts
+function e(e) {
+	for (let t of a(e)) if (i.has(t)) return !0;
+	return !1;
+}
+function t(e) {
+	for (let t of a(e)) {
+		let e = i.get(t);
+		if (e !== void 0) return e();
+	}
+}
+function n(e, t) {
+	r(e, () => new t());
+}
+function r(e, t) {
+	i.set(e, t);
+}
+var i = /* @__PURE__ */ new Map();
+function* a(e) {
+	let t = n(e);
+	for (;;) {
+		yield t;
+		let e = r(t);
+		if (e === void 0) return;
+		t = e;
+	}
+	function n(e) {
+		return e.constructor;
+	}
+	function r(e) {
+		return Object.getPrototypeOf(e.prototype)?.constructor ?? void 0;
+	}
+}
+//#endregion
+export { e as canCreateThreeView, t as createThreeView, a as getClassesOf, n as installThreeView, r as installThreeViewCreator };

package/dist/ui/components/AxisGizmo.d.ts

@@ -0,0 +1,9 @@
+import { ReactElement } from 'react';
+import { AxisGizmoOptions } from '@cognite/reveal/tools';
+export { AxisGizmoOptions };
+/**
+ * A React wrapper around the AxisGizmoTool from Reveal
+ */
+export declare const AxisGizmo: ({ options, }: {
+    options?: AxisGizmoOptions;
+}) => ReactElement;

package/dist/ui/components/AxisGizmo.js

@@ -0,0 +1,16 @@
+import { useReveal as e } from "./RevealCanvas/ViewerContext.js";
+import { useEffect as t } from "react";
+import { Fragment as n, jsx as r } from "react/jsx-runtime";
+import { AxisGizmoOptions as i, AxisGizmoTool as a } from "@cognite/reveal/tools";
+//#region libs/shared/reveal-components/src/ui/components/AxisGizmo.tsx
+var o = ({ options: i }) => {
+	let o = e();
+	return t(() => {
+		let e = new a(i);
+		return e.connect(o), () => {
+			e.dispose();
+		};
+	}, [o, i]), /* @__PURE__ */ r(n, {});
+};
+//#endregion
+export { o as AxisGizmo, i as AxisGizmoOptions };

package/dist/ui/components/CadModelContainer/CadModelContainer.context.d.ts

@@ -0,0 +1,17 @@
+import { Context } from 'react';
+import { RevealDomainObjectUtils } from '../../../domains/reveal/RevealDomainObjectUtils';
+import { useReveal3DResourceLoadFailCount, useReveal3DResourcesCount } from '../Reveal3DResources/Reveal3DResourcesInfoContext';
+import { useRenderTarget } from '../RevealCanvas';
+import { useRevealKeepAlive } from '../RevealKeepAlive/RevealKeepAliveContext';
+import { useApplyCadModelStyling } from './useApplyCadModelStyling';
+export type CadModelContextDependencies = {
+    useRevealKeepAlive: typeof useRevealKeepAlive;
+    useRenderTarget: typeof useRenderTarget;
+    useReveal3DResourcesCount: typeof useReveal3DResourcesCount;
+    useReveal3DResourceLoadFailCount: typeof useReveal3DResourceLoadFailCount;
+    useApplyCadModelStyling: typeof useApplyCadModelStyling;
+    createCadDomainObject: typeof RevealDomainObjectUtils.addCadDomainObject;
+    removeCadDomainObject: typeof RevealDomainObjectUtils.remove;
+};
+export declare const defaultCadModelContextDependencies: CadModelContextDependencies;
+export declare const CadModelContext: Context<CadModelContextDependencies>;

package/dist/ui/components/CadModelContainer/CadModelContainer.context.js

@@ -0,0 +1,19 @@
+import { useRenderTarget as e } from "../RevealCanvas/ViewerContext.js";
+import "../RevealCanvas/index.js";
+import { useReveal3DResourceLoadFailCount as t, useReveal3DResourcesCount as n } from "../Reveal3DResources/Reveal3DResourcesInfoContext.js";
+import { RevealDomainObjectUtils as r } from "../../../domains/reveal/RevealDomainObjectUtils.js";
+import { useRevealKeepAlive as i } from "../RevealKeepAlive/RevealKeepAliveContext.js";
+import { useApplyCadModelStyling as a } from "./useApplyCadModelStyling.js";
+import { createContext as o } from "react";
+//#region libs/shared/reveal-components/src/ui/components/CadModelContainer/CadModelContainer.context.ts
+var s = {
+	useRevealKeepAlive: i,
+	useRenderTarget: e,
+	useReveal3DResourcesCount: n,
+	useReveal3DResourceLoadFailCount: t,
+	useApplyCadModelStyling: a,
+	createCadDomainObject: r.addCadDomainObject.bind(void 0),
+	removeCadDomainObject: r.remove.bind(void 0)
+}, c = o(s);
+//#endregion
+export { c as CadModelContext, s as defaultCadModelContextDependencies };

package/dist/ui/components/CadModelContainer/CadModelContainer.d.ts

@@ -0,0 +1,13 @@
+import { ReactElement } from 'react';
+import { Matrix4 } from 'three';
+import { AddModelOptions, CogniteCadModel, ClassicDataSourceType, DataSourceType } from '@cognite/reveal';
+import { CadModelStyling } from './types';
+export type CogniteCadModelProps<T extends DataSourceType = ClassicDataSourceType> = {
+    addModelOptions: AddModelOptions<T>;
+    styling?: CadModelStyling;
+    transform?: Matrix4;
+    defaultVisible?: boolean;
+    onLoad?: (model: CogniteCadModel) => void;
+    onLoadError?: (options: AddModelOptions<T>, error: any) => void;
+};
+export declare function CadModelContainer<T extends DataSourceType = ClassicDataSourceType>({ addModelOptions, transform, styling, defaultVisible, onLoad, onLoadError, }: CogniteCadModelProps<T>): ReactElement;

package/dist/ui/components/CadModelContainer/CadModelContainer.js

@@ -0,0 +1,58 @@
+import { isClassicIdentifier as e, isDM3DModelIdentifier as t } from "../../../utilities/modelIds/typeGuards.js";
+import { getModelKeys as n } from "../../../utilities/getModelKeys.js";
+import { getViewerResourceCount as r } from "../../../utilities/getViewerResourceCount.js";
+import { isSameGeometryFilter as i, isSameModel as a } from "../../../utilities/isSameModel.js";
+import { modelExists as o } from "../../../utilities/modelExists.js";
+import { CadModelContext as s } from "./CadModelContainer.context.js";
+import { useContext as c, useEffect as l, useRef as u, useState as d } from "react";
+import { isEqual as f } from "lodash-es";
+import { Fragment as p, jsx as m } from "react/jsx-runtime";
+//#region libs/shared/reveal-components/src/ui/components/CadModelContainer/CadModelContainer.tsx
+function h({ addModelOptions: n, transform: h, styling: _, defaultVisible: v, onLoad: y, onLoadError: b }) {
+	let { useRenderTarget: x, useReveal3DResourceLoadFailCount: S, useReveal3DResourcesCount: C, useRevealKeepAlive: w, useApplyCadModelStyling: T, createCadDomainObject: E, removeCadDomainObject: D } = c(s), O = w(), k = x(), A = k.viewer, { setRevealResourcesCount: j } = C(), { setReveal3DResourceLoadFailCount: M } = S(), N = u(void 0), P = u(void 0), [F, I] = d(void 0), { geometryFilter: L } = n, R = e(n) ? n.modelId : void 0, z = e(n) ? n.revisionId : void 0, B = t(n) ? n.revisionExternalId : void 0, V = t(n) ? n.revisionSpace : void 0;
+	return l(() => {
+		if (f(N.current, n) || R === void 0 && B === void 0) return;
+		N.current = n;
+		let e = H(n, h).then((e) => (y?.(e), j(r(A)), () => {
+			U(e);
+		})).catch((e) => (b === void 0 ? g(n, e) : b(n, e), M((e) => e + 1), () => {
+			M((e) => e - 1);
+		}));
+		return () => {
+			e.then((e) => {
+				e();
+			});
+		};
+	}, [
+		R,
+		z,
+		B,
+		V,
+		L
+	]), l(() => {
+		!o(F, A) || h === void 0 || F.setModelTransformation(h);
+	}, [h, F]), T(F, _), /* @__PURE__ */ m(p, {});
+	async function H(e, t) {
+		let n = await r();
+		return t !== void 0 && n.setModelTransformation(t), I(n), n;
+		async function r() {
+			let t = A.models.find((t) => {
+				let n = {
+					...t,
+					transform: t.getModelTransformation()
+				};
+				return a(n, e) && i(L, P.current);
+			});
+			return t === void 0 ? (P.current = L, (await E(k, e, { defaultVisible: v })).model) : t;
+		}
+	}
+	function U(e) {
+		o(e, A) && (O !== void 0 && !O.isRevealContainerMountedRef.current || (D(k, e), j(r(A))));
+	}
+}
+function g(e, t) {
+	let r = n([e])[0];
+	console.warn(`Failed to load (${r}): ${JSON.stringify(t)}`);
+}
+//#endregion
+export { h as CadModelContainer };

package/dist/ui/components/CadModelContainer/index.d.ts

@@ -0,0 +1,3 @@
+export { CadModelContainer } from './CadModelContainer';
+export type { CogniteCadModelProps } from './CadModelContainer';
+export type { CadModelStyling } from './types';

package/dist/ui/components/CadModelContainer/index.js

@@ -0,0 +1,2 @@
+import { CadModelContainer as e } from "./CadModelContainer.js";
+export { e as CadModelContainer };