@cognite/reveal-components 1.0.0

package/dist/foundation/domainObjects/RootDomainObject.d.ts

@@ -0,0 +1,28 @@
+import { CogniteClient } from '@cognite/sdk';
+import { FdmSDK } from '../../data-providers/FdmSDK';
+import { RenderTarget } from '../renderTarget/RenderTarget';
+import { UnitSystem } from '../renderTarget/UnitSystem';
+import { TranslationInput } from '../utilities/translation/TranslateInput';
+import { IconName } from '../utilities/types';
+import { DomainObject } from './DomainObject';
+export declare class RootDomainObject extends DomainObject {
+    readonly unitSystem: UnitSystem;
+    private readonly _renderTarget;
+    private readonly _sdk;
+    private readonly _fdmSdk;
+    get renderTarget(): RenderTarget;
+    get sdk(): CogniteClient;
+    get fdmSdk(): FdmSDK;
+    constructor(renderTarget: RenderTarget, sdk: CogniteClient);
+    get typeName(): TranslationInput;
+    get icon(): IconName;
+    get hasIconColor(): boolean;
+    get hasIndexOnLabel(): boolean;
+    get isRoot(): boolean;
+    clone(what?: symbol): DomainObject;
+    addDefaultChildren(): void;
+    /**
+     * Cleans up all domain objects satisfying `cleanupPredicate`, or all if none is provided
+     */
+    cleanup(cleanupPredicate?: (obj: DomainObject) => boolean): void;
+}

package/dist/foundation/domainObjects/RootDomainObject.js

@@ -0,0 +1,55 @@
+import { Changes as e } from "../domainObjectsHelpers/Changes.js";
+import { UnitSystem as t } from "../renderTarget/UnitSystem.js";
+import { DomainObject as n } from "./DomainObject.js";
+import { AxisDomainObject as r } from "../../domains/axis/AxisDomainObject.js";
+import { FdmSDK as i } from "../../data-providers/FdmSDK.js";
+//#region libs/shared/reveal-components/src/foundation/domainObjects/RootDomainObject.ts
+var a = class a extends n {
+	unitSystem = new t();
+	_renderTarget;
+	_sdk;
+	_fdmSdk;
+	get renderTarget() {
+		return this._renderTarget;
+	}
+	get sdk() {
+		return this._sdk;
+	}
+	get fdmSdk() {
+		return this._fdmSdk;
+	}
+	constructor(t, n) {
+		super(), this._renderTarget = t, this._sdk = n, this._fdmSdk = new i(n), this.addDefaultChildren(), this.addEffect(() => {
+			this.unitSystem.lengthUnit(), this.notify(e.unit), this.notifyDescendants(e.unit);
+		});
+	}
+	get typeName() {
+		return { key: "SCENE" };
+	}
+	get icon() {
+		return "Tree";
+	}
+	get hasIconColor() {
+		return !1;
+	}
+	get hasIndexOnLabel() {
+		return !1;
+	}
+	get isRoot() {
+		return !0;
+	}
+	clone(e) {
+		let t = new a(this.renderTarget, this.sdk);
+		return t.copyFrom(this, e), t;
+	}
+	addDefaultChildren() {
+		this.addChildRaw(new r());
+	}
+	cleanup(e) {
+		[...this.getDescendants().filter(e ?? (() => !0))].reverse().forEach((e) => {
+			e.remove(!1);
+		}), this.addDefaultChildren();
+	}
+};
+//#endregion
+export { a as RootDomainObject };

package/dist/foundation/domainObjects/VisualDomainObject.d.ts

@@ -0,0 +1,41 @@
+import { Vector3, Ray } from 'three';
+import { BaseDragger } from '../domainObjectsHelpers/BaseDragger';
+import { DomainObjectIntersection } from '../domainObjectsHelpers/DomainObjectIntersection';
+import { FocusType } from '../domainObjectsHelpers/FocusType';
+import { VisibleState } from '../domainObjectsHelpers/VisibleState';
+import { RenderTarget } from '../renderTarget/RenderTarget';
+import { ThreeView } from '../views/ThreeView';
+import { DomainObject } from './DomainObject';
+/**
+ * Represents a visual domain object that can be rendered and manipulated in a three-dimensional space.
+ * This class extends the `DomainObject` class and provides additional functionality for visualization.
+ */
+export declare abstract class VisualDomainObject extends DomainObject {
+    focusType: FocusType;
+    getVisibleState(renderTarget?: RenderTarget): VisibleState;
+    setVisible(visible: boolean, renderTarget?: RenderTarget | undefined, doNotify?: boolean): boolean;
+    get isLegal(): boolean;
+    /**
+     * Factory method to create a dragger to interpret the mouse dragging operation
+     * This function is used in BaseEditTool
+     *
+     * @returns The dragger
+     */
+    createDragger(_props: CreateDraggerProps): BaseDragger | undefined;
+    get hasClippingInIntersection(): boolean;
+    getEditToolCursor(_renderTarget: RenderTarget, _point?: Vector3): string | undefined;
+    setFocus(focusType: FocusType): boolean;
+    getViewByTarget(renderTarget: RenderTarget): ThreeView | undefined;
+    /**
+     * Sets the visibility of the visual domain object for a specific target.
+     * @param visible - A boolean indicating whether the visual domain object should be visible or not.
+     * @param target - The target RenderTarget where the visual domain object will be attached.
+     * @returns A boolean indicating whether the state has changed.
+     */
+    private setVisibleRaw;
+}
+export type CreateDraggerProps = {
+    intersection: DomainObjectIntersection;
+    point: Vector3;
+    ray: Ray;
+};

package/dist/foundation/domainObjects/VisualDomainObject.js

@@ -0,0 +1,46 @@
+import { canCreateThreeView as e, createThreeView as t } from "../views/ThreeViewFactory.js";
+import { getRenderTarget as n } from "./getRoot.js";
+import { Changes as r } from "../domainObjectsHelpers/Changes.js";
+import { FocusType as i } from "../domainObjectsHelpers/FocusType.js";
+import { VisibleState as a } from "../domainObjectsHelpers/VisibleState.js";
+import { ThreeView as o } from "../views/ThreeView.js";
+import { DomainObject as s } from "./DomainObject.js";
+//#region libs/shared/reveal-components/src/foundation/domainObjects/VisualDomainObject.ts
+var c = class extends s {
+	focusType = i.None;
+	getVisibleState(t) {
+		return t === void 0 && (t = n(this), t === void 0) ? a.Disabled : this.getViewByTarget(t) === void 0 ? e(this) ? this.canBeSetVisibleNow(t) ? a.None : a.CanNotBeVisibleNow : a.Disabled : a.All;
+	}
+	setVisible(e, t = void 0, r = !0) {
+		return t === void 0 && (t = n(this), t === void 0) || e && !this.canBeSetVisibleNow(t) || !this.setVisibleRaw(e, t) ? !1 : (r && this.notifyVisibleStateChange(), !0);
+	}
+	get isLegal() {
+		return this.focusType !== i.Pending;
+	}
+	createDragger(e) {}
+	get hasClippingInIntersection() {
+		return !0;
+	}
+	getEditToolCursor(e, t) {}
+	setFocus(e) {
+		if (this.focusType === e) return !1;
+		let t = this.focusType === i.Pending && e !== i.Pending;
+		return this.focusType = e, this.notify(r.focus), t && this.notify(r.geometry), !0;
+	}
+	getViewByTarget(e) {
+		for (let t of this.views.getByType(o)) if (t.renderTarget === e) return t;
+	}
+	setVisibleRaw(e, n) {
+		let r = this.getViewByTarget(n);
+		if (e) {
+			if (r !== void 0 || (r = t(this), r === void 0)) return !1;
+			this.views.addView(r), r.attach(this, n), r.initialize(), r.onShow();
+		} else {
+			if (r === void 0) return !1;
+			this.views.removeView(r);
+		}
+		return !0;
+	}
+};
+//#endregion
+export { c as VisualDomainObject };

package/dist/foundation/domainObjects/getRoot.d.ts

@@ -0,0 +1,17 @@
+import { RenderTarget } from '../renderTarget/RenderTarget';
+import { DomainObject } from './DomainObject';
+import { RootDomainObject } from './RootDomainObject';
+/**
+ * Retrieves the root domain object if it is an instance of `RootDomainObject`.
+ *
+ * @param domainObject - The domain object from which to retrieve the root.
+ * @returns The root domain object if it is an instance of `RootDomainObject`, otherwise `undefined`.
+ */
+export declare function getRoot(domainObject: DomainObject): RootDomainObject | undefined;
+/**
+ * Retrieves the render target associated with the root of the given domain object.
+ *
+ * @param domainObject - The domain object for which to retrieve the render target.
+ * @returns The render target associated with the root of the domain object, or `undefined` if no render target is found.
+ */
+export declare function getRenderTarget(domainObject: DomainObject): RenderTarget | undefined;

package/dist/foundation/domainObjects/getRoot.js

@@ -0,0 +1,10 @@
+//#region libs/shared/reveal-components/src/foundation/domainObjects/getRoot.ts
+function e(e) {
+	let t = e.root;
+	if (t.isRoot) return t;
+}
+function t(t) {
+	return e(t)?.renderTarget;
+}
+//#endregion
+export { t as getRenderTarget, e as getRoot };

package/dist/foundation/domainObjectsHelpers/BaseCreator.d.ts

@@ -0,0 +1,61 @@
+import { Vector3, Ray } from 'three';
+import { DomainObject } from '../domainObjects/DomainObject';
+/**
+ * Helper class for create a domain object by clicking around
+ */
+export declare abstract class BaseCreator {
+    private readonly _points;
+    private _lastIsPending;
+    protected get points(): Vector3[];
+    protected get pointCount(): number;
+    get notPendingPointCount(): number;
+    protected get firstPoint(): Vector3;
+    protected get lastPoint(): Vector3;
+    protected get lastNotPendingPoint(): Vector3;
+    protected get lastIsPending(): boolean;
+    protected set lastIsPending(value: boolean);
+    /**
+     * Gets the value indicating whether to prefer intersection with something.
+     * If this is true, it will first try to intersect an object. If false the point
+     * will normally be calculated based on the previous point and the ray in addPointCore
+     *
+     * @returns {boolean} The value indicating whether to prefer intersection.
+     */
+    get preferIntersection(): boolean;
+    /**
+     * This functions returns true only if the first point can start on hover.
+     * This is to indicate where the object can be created when hovering.
+     *
+     * @returns {boolean} The value indicating whether to start on hover.
+     */
+    get canStartOnHover(): boolean;
+    abstract get domainObject(): DomainObject;
+    /**
+     * @returns The minimum required points to create the domain object.
+     */
+    abstract get minimumPointCount(): number;
+    /**
+     * @returns The maximum required points to create the domain object.
+     */
+    protected abstract get maximumPointCount(): number;
+    /**
+     * Adds a new point
+     * @param ray - The ray the camera has (in Cdf coordinates)
+     * @param point - The point to add.(in Cdf coordinates). If undefined, it indicates that
+     * it wasn't intersection anything. Then then ray and the previous point can be used to calculate the point.
+     * @param isPending - Indicates whether the point is pending (hover over instead of clicking).
+     * @returns A boolean value indicating whether the point was successfully added.
+     */
+    protected abstract addPointCore(ray: Ray, point: Vector3 | undefined, isPending: boolean): boolean;
+    /**
+     * Handles the escape key press event.
+     *
+     * @returns {boolean} Returns true if the pending object is created successfully, false if it is removed
+     */
+    escape(): boolean;
+    get isFinished(): boolean;
+    addPoint(ray: Ray, point?: Vector3, isPending?: boolean): boolean;
+    protected addRawPoint(point: Vector3, isPending: boolean): void;
+    protected removePendingPoint(): void;
+    private convertToCdfCoords;
+}

package/dist/foundation/domainObjectsHelpers/BaseCreator.js

@@ -0,0 +1,57 @@
+import { replaceLast as e } from "../utilities/extensions/arrayUtils.js";
+import { VIEWER_TO_CDF_TRANSFORMATION as t } from "../renderTarget/convertCoordinates.js";
+//#region libs/shared/reveal-components/src/foundation/domainObjectsHelpers/BaseCreator.ts
+var n = class {
+	_points = [];
+	_lastIsPending = !1;
+	get points() {
+		return this._points;
+	}
+	get pointCount() {
+		return this.points.length;
+	}
+	get notPendingPointCount() {
+		return this.lastIsPending ? this.pointCount - 1 : this.pointCount;
+	}
+	get firstPoint() {
+		return this.points[0];
+	}
+	get lastPoint() {
+		return this.points[this.pointCount - 1];
+	}
+	get lastNotPendingPoint() {
+		return this.points[this.notPendingPointCount - 1];
+	}
+	get lastIsPending() {
+		return this._lastIsPending;
+	}
+	set lastIsPending(e) {
+		this._lastIsPending = e;
+	}
+	get preferIntersection() {
+		return !1;
+	}
+	get canStartOnHover() {
+		return !1;
+	}
+	escape() {
+		return this.notPendingPointCount >= this.minimumPointCount || (this.domainObject.remove(), !1);
+	}
+	get isFinished() {
+		return this.notPendingPointCount >= this.maximumPointCount;
+	}
+	addPoint(e, t, n = !1) {
+		return t = t?.clone(), this.convertToCdfCoords(e, t), this.addPointCore(e, t, n);
+	}
+	addRawPoint(t, n) {
+		this.lastIsPending ? e(this.points, t) : this.points.push(t), this._lastIsPending = n;
+	}
+	removePendingPoint() {
+		this.lastIsPending && (this.points.pop(), this._lastIsPending = !1);
+	}
+	convertToCdfCoords(e, n) {
+		e.applyMatrix4(t), n !== void 0 && n.applyMatrix4(t);
+	}
+};
+//#endregion
+export { n as BaseCreator };

package/dist/foundation/domainObjectsHelpers/BaseDragger.d.ts

@@ -0,0 +1,47 @@
+import { Ray, Vector3 } from 'three';
+import { DomainObject } from '../domainObjects/DomainObject';
+import { VisualDomainObject, CreateDraggerProps } from '../domainObjects/VisualDomainObject';
+import { UnitSystem } from '../renderTarget/UnitSystem';
+import { Transaction } from '../undo/Transaction';
+/**
+ * The `BaseDragger` class represents a utility for dragging and manipulating any object in 3D space.
+ * It provides methods for onPointerDown, onPointerDrag, and onPointerUp based on user interactions.
+ */
+export declare const EPSILON = 0.000001;
+export declare abstract class BaseDragger {
+    protected readonly point: Vector3;
+    protected readonly ray: Ray;
+    private _transaction?;
+    protected readonly _unitSystem: UnitSystem;
+    isChanged: boolean;
+    get transaction(): Transaction | undefined;
+    protected set transaction(transaction: Transaction);
+    /**
+     * Represents a base dragger object.
+     * @param props - Contains the ray amd the clicked point in CDF coordinates
+     * @param domainObject - The domain object to act on
+     */
+    protected constructor(props: CreateDraggerProps, domainObject: DomainObject);
+    /**
+     * Returns the domain object to be manipulated
+     */
+    abstract get domainObject(): VisualDomainObject;
+    /**
+     * Called just after the dragger is created and the pointer is down.
+     * @param _event - The pointer event object.
+     */
+    onPointerDown(_event: PointerEvent): void;
+    /**
+     * Called every times the mouse moves during dragging
+     * @param event - The pointer event.
+     * @param ray - The current ray in CDF coordinates
+     * @returns True if the dragger has changed the domain object, false otherwise.
+     */
+    abstract onPointerDrag(event: PointerEvent, ray: Ray): boolean;
+    /**
+     * Called just before the dragger is deleted.
+     * @param _event - The pointer event.
+     */
+    onPointerUp(_event: PointerEvent): void;
+    protected getBestValue(value: number, isShiftPressed: boolean, minValue: number): number;
+}

package/dist/foundation/domainObjectsHelpers/BaseDragger.js

@@ -0,0 +1,34 @@
+import { getRoot as e } from "../domainObjects/getRoot.js";
+import { Changes as t } from "./Changes.js";
+import { Quantity as n } from "./Quantity.js";
+import { round as r, roundIncrement as i } from "../utilities/extensions/mathUtils.js";
+import { UNDEFINED_UNIT_SYSTEM as a } from "../renderTarget/UnitSystem.js";
+import { Ray as o } from "three";
+//#region libs/shared/reveal-components/src/foundation/domainObjectsHelpers/BaseDragger.ts
+var s = 1e-6, c = class {
+	point;
+	ray = new o();
+	_transaction;
+	_unitSystem;
+	isChanged = !1;
+	get transaction() {
+		return this._transaction;
+	}
+	set transaction(e) {
+		this._transaction = e;
+	}
+	constructor(t, n) {
+		this.point = t.point, this.ray = t.ray, this._unitSystem = e(n)?.unitSystem ?? a;
+	}
+	onPointerDown(e) {}
+	onPointerUp(e) {
+		this.isChanged && this.domainObject.notify(t.geometry);
+	}
+	getBestValue(e, t, a) {
+		if (e < a && (e = a), !t) return e;
+		let o = this._unitSystem.convertToUnit(e, n.Length), s = i(o / 25), c = r(o, s), l = this._unitSystem.convertFromUnit(c, n.Length);
+		return l < a ? a : l;
+	}
+};
+//#endregion
+export { c as BaseDragger, s as EPSILON };

package/dist/foundation/domainObjectsHelpers/ChangedDescription.d.ts

@@ -0,0 +1,6 @@
+export declare class ChangedDescription {
+    change: symbol;
+    fieldName: string | undefined;
+    constructor(change: symbol, fieldName?: string);
+    isChanged(fieldName: string): boolean;
+}

package/dist/foundation/domainObjectsHelpers/ChangedDescription.js

@@ -0,0 +1,14 @@
+import { equalsIgnoreCaseAndSpace as e } from "../utilities/extensions/stringUtils.js";
+//#region libs/shared/reveal-components/src/foundation/domainObjectsHelpers/ChangedDescription.ts
+var t = class {
+	change;
+	fieldName;
+	constructor(e, t) {
+		this.change = e, this.fieldName = t;
+	}
+	isChanged(t) {
+		return this.fieldName !== void 0 && e(this.fieldName, t);
+	}
+};
+//#endregion
+export { t as ChangedDescription };

package/dist/foundation/domainObjectsHelpers/Changes.d.ts

@@ -0,0 +1,27 @@
+export declare class Changes {
+    static readonly visibleState: symbol;
+    static readonly active: symbol;
+    static readonly expanded: symbol;
+    static readonly selected: symbol;
+    static readonly hovered: symbol;
+    static readonly focus: symbol;
+    static readonly clipping: symbol;
+    static readonly naming: symbol;
+    static readonly color: symbol;
+    static readonly icon: symbol;
+    static readonly colorMap: symbol;
+    static readonly renderStyle: symbol;
+    static readonly unit: symbol;
+    static readonly geometry: symbol;
+    static readonly dragging: symbol;
+    static readonly changedPart: symbol;
+    static readonly deletedPart: symbol;
+    static readonly addedPart: symbol;
+    static readonly newPending: symbol;
+    static readonly added: symbol;
+    static readonly deleting: symbol;
+    static readonly deleted: symbol;
+    static readonly childDeleted: symbol;
+    static readonly childAdded: symbol;
+    static readonly loaded: symbol;
+}

package/dist/foundation/domainObjectsHelpers/Changes.js

@@ -0,0 +1,30 @@
+//#region libs/shared/reveal-components/src/foundation/domainObjectsHelpers/Changes.ts
+var e = class {
+	static visibleState = Symbol("visibleState");
+	static active = Symbol("active");
+	static expanded = Symbol("expanded");
+	static selected = Symbol("selected");
+	static hovered = Symbol("hovered");
+	static focus = Symbol("focus");
+	static clipping = Symbol("clipping");
+	static naming = Symbol("naming");
+	static color = Symbol("color");
+	static icon = Symbol("icon");
+	static colorMap = Symbol("colorMap");
+	static renderStyle = Symbol("renderStyle");
+	static unit = Symbol("unit");
+	static geometry = Symbol("geometry");
+	static dragging = Symbol("dragging");
+	static changedPart = Symbol("changedPart");
+	static deletedPart = Symbol("deletedPart");
+	static addedPart = Symbol("addedPart");
+	static newPending = Symbol("newPending");
+	static added = Symbol("added");
+	static deleting = Symbol("deleting");
+	static deleted = Symbol("deleted");
+	static childDeleted = Symbol("childDeleted");
+	static childAdded = Symbol("childAdded");
+	static loaded = Symbol("loaded");
+};
+//#endregion
+export { e as Changes };

package/dist/foundation/domainObjectsHelpers/Class.d.ts

@@ -0,0 +1,4 @@
+export type Class<T> = Function & {
+    prototype: T;
+};
+export declare function isInstanceOf<T>(value: unknown, classType: Class<T>): value is T;

package/dist/foundation/domainObjectsHelpers/Class.js

@@ -0,0 +1,6 @@
+//#region libs/shared/reveal-components/src/foundation/domainObjectsHelpers/Class.ts
+function e(e, t) {
+	return e instanceof t;
+}
+//#endregion
+export { e as isInstanceOf };

package/dist/foundation/domainObjectsHelpers/ColorType.d.ts

@@ -0,0 +1,8 @@
+export declare enum ColorType {
+    Specified = 0,// Use the color of the domain object itself
+    Parent = 1,// Use the color of the parent domain object
+    Black = 2,
+    White = 3,
+    Different = 4,// Use different colors (normally use for debugging)
+    ColorMap = 5
+}

package/dist/foundation/domainObjectsHelpers/ColorType.js

@@ -0,0 +1,6 @@
+//#region libs/shared/reveal-components/src/foundation/domainObjectsHelpers/ColorType.ts
+var e = /* @__PURE__ */ function(e) {
+	return e[e.Specified = 0] = "Specified", e[e.Parent = 1] = "Parent", e[e.Black = 2] = "Black", e[e.White = 3] = "White", e[e.Different = 4] = "Different", e[e.ColorMap = 5] = "ColorMap", e;
+}({});
+//#endregion
+export { e as ColorType };

package/dist/foundation/domainObjectsHelpers/CommandChanges.d.ts

@@ -0,0 +1,4 @@
+export declare class CommandChanges {
+    static readonly active: symbol;
+    static readonly deactive: symbol;
+}

package/dist/foundation/domainObjectsHelpers/CommandChanges.js

@@ -0,0 +1,7 @@
+//#region libs/shared/reveal-components/src/foundation/domainObjectsHelpers/CommandChanges.ts
+var e = class {
+	static active = Symbol("active");
+	static deactive = Symbol("deactive");
+};
+//#endregion
+export { e as CommandChanges };

package/dist/foundation/domainObjectsHelpers/DomainObjectChange.d.ts

@@ -0,0 +1,28 @@
+import { ChangedDescription } from './ChangedDescription';
+import { Class } from './Class';
+export declare class DomainObjectChange {
+    private _changes;
+    constructor(change?: symbol | ChangedDescription, fieldName?: string);
+    get isEmpty(): boolean;
+    /**
+     * Checks if the domain object has been changed based on the specified changes.
+     * @param changes - The changes to check.
+     * @returns `true` if any of the specified changes are present in the domain object, `false` otherwise.
+     */
+    isChanged(...changes: symbol[]): boolean;
+    /**
+     * Checks if the domain object has been changed based on the specified change and some specific field names.
+     * For instance
+     * if (isFieldNameChanged(Changes.renderStyle, 'lineWidth', 'lineColor')) {
+     *   // Now you have to update the line material only
+     * }
+     * @param change - The symbol representing the change.
+     * @param fieldNames - The field names to compare against the change symbol.
+     * @returns A boolean indicating whether the name has changed or not.
+     */
+    isFieldNameChanged(change: symbol, ...fieldNames: string[]): boolean;
+    getChangedDescription(change: symbol): ChangedDescription | undefined;
+    getChangedDescriptionByType<T extends ChangedDescription>(classType: Class<T>): T | undefined;
+    addChange(change: symbol, fieldName?: string): void;
+    addChangedDescription(changedDescription: ChangedDescription): void;
+}

package/dist/foundation/domainObjectsHelpers/DomainObjectChange.js

@@ -0,0 +1,39 @@
+import { isInstanceOf as e } from "./Class.js";
+import { ChangedDescription as t } from "./ChangedDescription.js";
+//#region libs/shared/reveal-components/src/foundation/domainObjectsHelpers/DomainObjectChange.ts
+var n = class {
+	_changes = void 0;
+	constructor(e, n) {
+		typeof e == "symbol" && this.addChange(e, n), e instanceof t && this.addChangedDescription(e);
+	}
+	get isEmpty() {
+		return this._changes === void 0 || this._changes.length === 0;
+	}
+	isChanged(...e) {
+		if (this._changes === void 0) return !1;
+		for (let t of e) if (this._changes.some((e) => e.change === t)) return !0;
+		return !1;
+	}
+	isFieldNameChanged(e, ...t) {
+		let n = this.getChangedDescription(e);
+		if (n === void 0) return !1;
+		for (let e of t) if (n.isChanged(e)) return !0;
+		return !1;
+	}
+	getChangedDescription(e) {
+		if (this._changes !== void 0) return this._changes.find((t) => t.change === e);
+	}
+	getChangedDescriptionByType(t) {
+		if (this._changes !== void 0) {
+			for (let n of this._changes) if (e(n, t)) return n;
+		}
+	}
+	addChange(e, n) {
+		e !== void 0 && this.addChangedDescription(new t(e, n));
+	}
+	addChangedDescription(e) {
+		this._changes === void 0 && (this._changes = []), this._changes.push(e);
+	}
+};
+//#endregion
+export { n as DomainObjectChange };

package/dist/foundation/domainObjectsHelpers/DomainObjectIntersection.d.ts

@@ -0,0 +1,8 @@
+import { CustomObjectIntersection, AnyIntersection } from '@cognite/reveal';
+import { DomainObject } from '../domainObjects/DomainObject';
+export type DomainObjectIntersection = CustomObjectIntersection & {
+    domainObject: DomainObject;
+    onClick?: () => void;
+};
+export declare function isDomainObjectIntersection(intersection: AnyIntersection | undefined): intersection is DomainObjectIntersection;
+export declare function isCustomObjectIntersection(intersection: AnyIntersection | undefined): intersection is CustomObjectIntersection;

package/dist/foundation/domainObjectsHelpers/DomainObjectIntersection.js

@@ -0,0 +1,9 @@
+//#region libs/shared/reveal-components/src/foundation/domainObjectsHelpers/DomainObjectIntersection.ts
+function e(e) {
+	return e?.domainObject !== void 0;
+}
+function t(e) {
+	return e?.type === "customObject";
+}
+//#endregion
+export { t as isCustomObjectIntersection, e as isDomainObjectIntersection };

package/dist/foundation/domainObjectsHelpers/FocusType.d.ts

@@ -0,0 +1,9 @@
+export declare enum FocusType {
+    None = 0,
+    Focus = 1,// Focus not any particular place
+    Face = 2,// Focus on the face
+    Corner = 3,// Focus on a corner
+    Rotation = 4,// Focus at rotation
+    Body = 5,// Pick on any other places then Face, Corner or Rotation
+    Pending = 6
+}

package/dist/foundation/domainObjectsHelpers/FocusType.js

@@ -0,0 +1,6 @@
+//#region libs/shared/reveal-components/src/foundation/domainObjectsHelpers/FocusType.ts
+var e = /* @__PURE__ */ function(e) {
+	return e[e.None = 0] = "None", e[e.Focus = 1] = "Focus", e[e.Face = 2] = "Face", e[e.Corner = 3] = "Corner", e[e.Rotation = 4] = "Rotation", e[e.Body = 5] = "Body", e[e.Pending = 6] = "Pending", e;
+}({});
+//#endregion
+export { e as FocusType };