@cognite/reveal-components 1.0.0

package/dist/foundation/utilities/geometry/Range3.d.ts

@@ -0,0 +1,45 @@
+import { Vector2, Vector3, Box3, Plane } from 'three';
+import { Range1 } from './Range1';
+export declare class Range3 {
+    static readonly empty: Range3;
+    x: Range1;
+    y: Range1;
+    z: Range1;
+    get isEmpty(): boolean;
+    get min(): Vector3;
+    get max(): Vector3;
+    get delta(): Vector3;
+    get center(): Vector3;
+    get diagonal(): number;
+    get area(): number;
+    get volume(): number;
+    constructor(min?: Vector3, max?: Vector3);
+    clone(): Range3;
+    equals(other: Range3 | undefined): boolean;
+    isInside(point: Vector3): boolean;
+    toString(): string;
+    getMin(target: Vector3): Vector3;
+    getMax(target: Vector3): Vector3;
+    getDelta(target: Vector3): Vector3;
+    getCenter(target: Vector3): Vector3;
+    getBox(target?: Box3): Box3;
+    getCornerPoints(corners: Vector3[]): Vector3[];
+    getCornerPoint(corner: number, target: Vector3): Vector3;
+    getHorizontalIntersection(plane: Plane, cornerIndex: number): Vector3;
+    private getIntersectionOfEdge;
+    getVerticalPlaneIntersection(plane: Plane, isTop: boolean, // Give top or bottom of the range here
+    start: Vector3, end: Vector3): boolean;
+    makeEmpty(): void;
+    copy(box: Box3): void;
+    set(min: Vector3, max: Vector3): void;
+    translate(value: Vector3): void;
+    scale(value: number): void;
+    add(value: Vector3): void;
+    addHorizontal(value: Vector2 | Vector3): void;
+    addRange(value: Range3 | undefined): void;
+    expandByMargin(margin: number): void;
+    expandByMargin3(margin: Vector3): void;
+    expandByFraction(fraction: number): void;
+    static createCube(halfSize: number): Range3;
+    static getCircleRangeMargin(normal: Vector3, radius: number): Vector3;
+}

package/dist/foundation/utilities/geometry/Range3.js

@@ -0,0 +1,156 @@
+import { square as e } from "../extensions/mathUtils.js";
+import { Range1 as t } from "./Range1.js";
+import { Box3 as n, Line3 as r, Vector3 as i } from "three";
+import { Vector3Pool as a } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/foundation/utilities/geometry/Range3.ts
+var o = class r {
+	static empty = new r();
+	x = new t();
+	y = new t();
+	z = new t();
+	get isEmpty() {
+		return this.x.isEmpty || this.y.isEmpty || this.z.isEmpty;
+	}
+	get min() {
+		return new i(this.x.min, this.y.min, this.z.min);
+	}
+	get max() {
+		return new i(this.x.max, this.y.max, this.z.max);
+	}
+	get delta() {
+		return new i(this.x.delta, this.y.delta, this.z.delta);
+	}
+	get center() {
+		return new i(this.x.center, this.y.center, this.z.center);
+	}
+	get diagonal() {
+		return Math.sqrt(e(this.x.delta) + e(this.y.delta) + e(this.z.delta));
+	}
+	get area() {
+		return 2 * (this.x.delta * this.y.delta + this.y.delta * this.z.delta + this.z.delta * this.x.delta);
+	}
+	get volume() {
+		return this.x.delta * this.y.delta * this.z.delta;
+	}
+	constructor(e, t) {
+		e === void 0 && t !== void 0 ? this.set(t, t) : e !== void 0 && t === void 0 ? this.set(e, e) : e !== void 0 && t !== void 0 && this.set(e, t);
+	}
+	clone() {
+		let e = new r();
+		return e.x = this.x.clone(), e.y = this.y.clone(), e.z = this.z.clone(), e;
+	}
+	equals(e) {
+		return e !== void 0 && this.x.equals(e.x) && this.y.equals(e.y) && this.z.equals(e.z);
+	}
+	isInside(e) {
+		return this.x.isInside(e.x) && this.y.isInside(e.y) && this.z.isInside(e.z);
+	}
+	toString() {
+		return `(X: ${this.x.toString()}, Y: ${this.y.toString()}, Z: ${this.z.toString()})`;
+	}
+	getMin(e) {
+		return e.set(this.x.min, this.y.min, this.z.min);
+	}
+	getMax(e) {
+		return e.set(this.x.max, this.y.max, this.z.max);
+	}
+	getDelta(e) {
+		return e.set(this.x.delta, this.y.delta, this.z.delta);
+	}
+	getCenter(e) {
+		return e.set(this.x.center, this.y.center, this.z.center);
+	}
+	getBox(e) {
+		return e === void 0 && (e = new n()), e.min.set(this.x.min, this.y.min, this.z.min), e.max.set(this.x.max, this.y.max, this.z.max), e;
+	}
+	getCornerPoints(e) {
+		for (let t = 0; t < 8; t++) this.getCornerPoint(t, e[t]);
+		return e;
+	}
+	getCornerPoint(e, t) {
+		switch (e) {
+			case 0: return t.set(this.x.min, this.y.min, this.z.min);
+			case 1: return t.set(this.x.max, this.y.min, this.z.min);
+			case 2: return t.set(this.x.max, this.y.max, this.z.min);
+			case 3: return t.set(this.x.min, this.y.max, this.z.min);
+			case 4: return t.set(this.x.min, this.y.min, this.z.max);
+			case 5: return t.set(this.x.max, this.y.min, this.z.max);
+			case 6: return t.set(this.x.max, this.y.max, this.z.max);
+			case 7: return t.set(this.x.min, this.y.max, this.z.max);
+			default: throw Error("getCornerPoint");
+		}
+	}
+	getHorizontalIntersection(e, t) {
+		let n = this.getCornerPoint(t, l());
+		return e.projectPoint(n, n);
+	}
+	getIntersectionOfEdge(e, t, n) {
+		let r = this.getCornerPoint(t, l()), i = this.getCornerPoint(n, l());
+		return s.set(r, i), e.intersectLine(s, l()) ?? void 0;
+	}
+	getVerticalPlaneIntersection(e, t, n, r) {
+		let i = t ? 4 : 0, a = 0;
+		for (let t = 0; t < 4; t++) {
+			let o = i + t, s = i + (t + 1) % 4, c = this.getIntersectionOfEdge(e, o, s);
+			if (c !== void 0) {
+				if (a === 0) {
+					n.copy(c), a++;
+					continue;
+				}
+				if (a === 1) {
+					r.copy(c), a++;
+					break;
+				}
+			}
+		}
+		return a >= 2;
+	}
+	makeEmpty() {
+		this.x.makeEmpty(), this.y.makeEmpty(), this.z.makeEmpty();
+	}
+	copy(e) {
+		e.isEmpty() ? this.makeEmpty() : this.set(e.min, e.max);
+	}
+	set(e, t) {
+		this.x.set(e.x, t.x), this.y.set(e.y, t.y), this.z.set(e.z, t.z);
+	}
+	translate(e) {
+		this.x.translate(e.x), this.y.translate(e.y), this.z.translate(e.z);
+	}
+	scale(e) {
+		this.x.scale(e), this.y.scale(e), this.z.scale(e);
+	}
+	add(e) {
+		this.x.add(e.x), this.y.add(e.y), this.z.add(e.z);
+	}
+	addHorizontal(e) {
+		this.x.add(e.x), this.y.add(e.y);
+	}
+	addRange(e) {
+		e !== void 0 && (this.x.addRange(e.x), this.y.addRange(e.y), this.z.addRange(e.z));
+	}
+	expandByMargin(e) {
+		this.x.expandByMargin(e), this.y.expandByMargin(e), this.z.expandByMargin(e);
+	}
+	expandByMargin3(e) {
+		this.x.expandByMargin(e.x), this.y.expandByMargin(e.y), this.z.expandByMargin(e.z);
+	}
+	expandByFraction(e) {
+		this.x.expandByFraction(e), this.y.expandByFraction(e), this.z.expandByFraction(e);
+	}
+	static createCube(e) {
+		let t = new r();
+		return t.x.set(-e, e), t.y.set(-e, e), t.z.set(-e, e), t;
+	}
+	static getCircleRangeMargin(e, t) {
+		let n = e.clone();
+		n.multiply(e), n.x > 1 && (n.x = 1), n.y > 1 && (n.y = 1), n.z > 1 && (n.z = 1);
+		let r = n.set(Math.sqrt(1 - n.x), Math.sqrt(1 - n.y), Math.sqrt(1 - n.z));
+		return r.multiplyScalar(t), r;
+	}
+}, s = new r(), c = new a();
+function l(e) {
+	return c.getNext(e);
+}
+//#endregion
+export { o as Range3 };

package/dist/foundation/utilities/geometry/Shape.d.ts

@@ -0,0 +1,10 @@
+import { Range1 } from './Range1';
+import { Range3 } from './Range3';
+export declare abstract class Shape {
+    private _boundingBox;
+    get zRange(): Range1;
+    get boundingBox(): Range3;
+    abstract clone(): Shape;
+    abstract expandBoundingBox(boundingBox: Range3): void;
+    touch(): void;
+}

package/dist/foundation/utilities/geometry/TrianglesBuffers.d.ts

@@ -0,0 +1,20 @@
+import { BufferGeometry, Vector3 } from 'three';
+export declare class TrianglesBuffers {
+    protected positions: Float32Array;
+    protected normals: Float32Array | undefined;
+    protected uvs: Float32Array | undefined;
+    protected triangleIndexes: number[];
+    protected uniqueIndex: number;
+    get isFilled(): boolean;
+    constructor(pointCount: number, makeNormals?: boolean, makeUvs?: boolean);
+    createBufferGeometry(): BufferGeometry;
+    addPairWithNormals(p1: Vector3, p2: Vector3, n1: Vector3, n2: Vector3, u?: number): void;
+    addPairWithNormal(p1: Vector3, p2: Vector3, normal: Vector3, u?: number): void;
+    addTriangle(index0: number, index1: number, index2: number): void;
+    add(position: Vector3, normal: Vector3, u?: number, v?: number): void;
+    addPosition(position: Vector3): void;
+    setAt(index: number, position: Vector3, normal: Vector3, u?: number, v?: number): void;
+    private setPositionAt;
+    private setNormalAt;
+    private setUvAt;
+}

package/dist/foundation/utilities/geometry/TrianglesBuffers.js

@@ -0,0 +1,57 @@
+import { BufferGeometry as e, Float32BufferAttribute as t, Uint32BufferAttribute as n } from "three";
+//#region libs/shared/reveal-components/src/foundation/utilities/geometry/TrianglesBuffers.ts
+var r = class {
+	positions;
+	normals = void 0;
+	uvs = void 0;
+	triangleIndexes = [];
+	uniqueIndex = 0;
+	get isFilled() {
+		return this.uniqueIndex === this.positions.length / 3;
+	}
+	constructor(e, t = !0, n = !1) {
+		this.positions = new Float32Array(3 * e), t && (this.normals = new Float32Array(3 * e)), n && (this.uvs = new Float32Array(2 * e));
+	}
+	createBufferGeometry() {
+		let r = new e();
+		return r.setAttribute("position", new t(this.positions, 3, !0)), this.normals !== void 0 && r.setAttribute("normal", new t(this.normals, 3, !1)), r.setIndex(new n(this.triangleIndexes, 1, !0)), this.uvs !== void 0 && r.setAttribute("uv", new t(this.uvs, 2, !0)), r;
+	}
+	addPairWithNormals(e, t, n, r, i = 0) {
+		if (this.uniqueIndex >= 2) {
+			let e = this.uniqueIndex - 2, t = this.uniqueIndex - 1, n = this.uniqueIndex, r = this.uniqueIndex + 1;
+			this.addTriangle(e, r, n), this.addTriangle(e, t, r);
+		}
+		this.add(e, n, i), this.add(t, r, i);
+	}
+	addPairWithNormal(e, t, n, r = 0) {
+		this.addPairWithNormals(e, t, n, n, r);
+	}
+	addTriangle(e, t, n) {
+		this.triangleIndexes.push(e, t, n);
+	}
+	add(e, t, n = 0, r = 0) {
+		this.setAt(this.uniqueIndex, e, t, n, r), this.uniqueIndex++;
+	}
+	addPosition(e) {
+		this.setPositionAt(this.uniqueIndex, e), this.uniqueIndex++;
+	}
+	setAt(e, t, n, r = 0, i = 0) {
+		this.setPositionAt(e, t), this.setNormalAt(e, n), this.setUvAt(e, r, i);
+	}
+	setPositionAt(e, t) {
+		let n = 3 * e;
+		this.positions[n + 0] = t.x, this.positions[n + 1] = t.y, this.positions[n + 2] = t.z;
+	}
+	setNormalAt(e, t) {
+		if (this.normals === void 0) return;
+		let n = 3 * e;
+		this.normals[n + 0] = t.x, this.normals[n + 1] = t.y, this.normals[n + 2] = t.z;
+	}
+	setUvAt(e, t = 0, n = 0) {
+		if (this.uvs === void 0) return;
+		let r = 2 * e;
+		this.uvs[r + 0] = t, this.uvs[r + 1] = n;
+	}
+};
+//#endregion
+export { r as TrianglesBuffers };

package/dist/foundation/utilities/geometry/getBoundingBoxFromPlanes.d.ts

@@ -0,0 +1,3 @@
+import { Plane } from 'three';
+import { Range3 } from './Range3';
+export declare function getBoundingBoxFromPlanes(planes: Plane[], originalBoundingBox: Range3): Range3;

package/dist/foundation/utilities/geometry/getBoundingBoxFromPlanes.js

@@ -0,0 +1,53 @@
+import { Range3 as e } from "./Range3.js";
+import { Line3 as t, Vector3 as n } from "three";
+//#region libs/shared/reveal-components/src/foundation/utilities/geometry/getBoundingBoxFromPlanes.ts
+function r(r, i) {
+	let a = new e(), o = new n();
+	{
+		let e = r.filter((e) => s(e));
+		for (let t = 0; t < 8; t += 4) {
+			let n = i.getCornerPoint(t, o);
+			l(e, n) && a.z.add(n.z);
+		}
+		let t = new n(0, 0, 0);
+		for (let n of e) {
+			let r = n.projectPoint(t, o);
+			l(e, r, n) && i.z.isInside(r.z) && a.z.add(r.z);
+		}
+	}
+	{
+		let e = r.filter((e) => c(e));
+		for (let t = 0; t < 8; t++) {
+			let n = i.getCornerPoint(t, o);
+			l(e, n) && a.addHorizontal(n);
+		}
+		for (let r of e) {
+			let s = new n(), c = new n();
+			if (!i.getVerticalPlaneIntersection(r, !1, s, c)) continue;
+			let u = [];
+			u.push(new t(s, c));
+			for (let i of e) {
+				if (i === r) continue;
+				let e = u.length;
+				for (let r = 0; r < e; r++) {
+					let e = u[r], a = i.intersectLine(e, new n());
+					a !== null && (u.push(new t(a, e.end.clone())), e.end.copy(a));
+				}
+			}
+			for (let t of u) l(e, t.getCenter(o), r) && (a.addHorizontal(t.start), a.addHorizontal(t.end));
+		}
+	}
+	return a;
+	function s(e) {
+		return e.normal.x === 0 && e.normal.y === 0;
+	}
+	function c(e) {
+		return e.normal.z === 0;
+	}
+	function l(e, t, n) {
+		for (let r of e) if ((n === void 0 || r !== n) && r.distanceToPoint(t) < 0) return !1;
+		return !0;
+	}
+}
+//#endregion
+export { r as getBoundingBoxFromPlanes };

package/dist/foundation/utilities/geometry/getCorners.d.ts

@@ -0,0 +1,2 @@
+import { Box3, Vector3 } from 'three';
+export declare function getCorners(box: Box3, target?: Vector3): Generator<Vector3>;

package/dist/foundation/utilities/geometry/getCorners.js

@@ -0,0 +1,7 @@
+import { Vector3 as e } from "three";
+//#region libs/shared/reveal-components/src/foundation/utilities/geometry/getCorners.ts
+function* t(t, n) {
+	n === void 0 && (n = new e()), n.set(t.min.x, t.min.y, t.min.z), yield n, n.set(t.max.x, t.min.y, t.min.z), yield n, n.set(t.max.x, t.max.y, t.min.z), yield n, n.set(t.min.x, t.max.y, t.min.z), yield n, n.set(t.min.x, t.min.y, t.max.z), yield n, n.set(t.max.x, t.min.y, t.max.z), yield n, n.set(t.max.x, t.max.y, t.max.z), yield n, n.set(t.min.x, t.max.y, t.max.z), yield n;
+}
+//#endregion
+export { t as getCorners };

package/dist/foundation/utilities/geometry/getResizeCursor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns the appropriate CSS cursor value based on the given octant.
+ *
+ * The octant is a number from 0 to 7 that represents a direction for resizing.
+ * The function maps these octants to corresponding CSS cursor values.
+ *
+ * @param octant - A number from 0 to 7 representing the direction for resizing.
+ * @returns The CSS cursor value as a string, or `undefined` if the octant is not valid.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/cursor
+ */
+export declare function getResizeCursor(octant: number): string | undefined;

package/dist/foundation/utilities/geometry/getResizeCursor.js

@@ -0,0 +1,16 @@
+//#region libs/shared/reveal-components/src/foundation/utilities/geometry/getResizeCursor.ts
+function e(e) {
+	switch (e) {
+		case 2:
+		case 6: return "ns-resize";
+		case 1:
+		case 5: return "nesw-resize";
+		case 0:
+		case 4: return "ew-resize";
+		case 3:
+		case 7: return "nwse-resize";
+		default: return;
+	}
+}
+//#endregion
+export { e as getResizeCursor };

package/dist/foundation/utilities/geometry/isBoxVisibleByPlanes.d.ts

@@ -0,0 +1,3 @@
+import { Box3, Plane } from 'three';
+export declare function isAnyCornersVisibleByPlanes(planes: Plane[], box: Box3): boolean;
+export declare function isEntireBoxVisibleByPlanes(planes: Plane[], box: Box3): boolean;

package/dist/foundation/utilities/geometry/isBoxVisibleByPlanes.js

@@ -0,0 +1,12 @@
+import { getCorners as e } from "./getCorners.js";
+import { Vector3 as t } from "three";
+import { isPointVisibleByPlanes as n } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/foundation/utilities/geometry/isBoxVisibleByPlanes.ts
+var r = new t();
+function i(t, i) {
+	if (i.isEmpty()) return !1;
+	for (let a of e(i, r)) if (n(t, a)) return !0;
+	return !1;
+}
+//#endregion
+export { i as isAnyCornersVisibleByPlanes };

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

@@ -0,0 +1 @@
+export { CheckboxState } from './types';

package/dist/foundation/utilities/index.js

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

package/dist/foundation/utilities/misc/DeferredFunction.d.ts

@@ -0,0 +1,13 @@
+export declare class DeferredFunction {
+    private readonly _trigger;
+    private readonly _debouncedTrigger;
+    private readonly _disposeEffect;
+    constructor(func: () => void);
+    /**
+     * Triggers a deferred function by incrementing the internal trigger.
+     * This method is typically used to signal that update should occur,
+     * without performing the update immediately.
+     */
+    trigger(): void;
+    dispose(): void;
+}

package/dist/foundation/utilities/misc/DeferredFunction.js

@@ -0,0 +1,21 @@
+import { incrementSignal as e } from "./incrementSignal.js";
+import { debouncedComputed as t, effect as n, signal as r } from "@cognite/signal-utils";
+//#region libs/shared/reveal-components/src/foundation/utilities/misc/DeferredFunction.ts
+var i = class {
+	_trigger = r(0);
+	_debouncedTrigger = t(() => this._trigger(), 1);
+	_disposeEffect;
+	constructor(e) {
+		this._disposeEffect = n(() => {
+			this._debouncedTrigger.value() > 0 && e();
+		});
+	}
+	trigger() {
+		e(this._trigger);
+	}
+	dispose() {
+		this._debouncedTrigger.dispose(), this._disposeEffect();
+	}
+};
+//#endregion
+export { i as DeferredFunction };

package/dist/foundation/utilities/misc/Random.d.ts

@@ -0,0 +1,39 @@
+import { Box3, Color, Vector3 } from 'three';
+/**
+ * Utility class for generating pseudo-random numbers and vectors with a seed-able random number generator.
+ *
+ * The reason for making this class was that the SeededRandom library was hard to use directly
+ * and to collect all random function in one place.
+ *
+ * It sets the seed in the constructor, so the random numbers are predictable when writing tests.
+ *
+ * @remarks
+ * This class wraps a seeded random number generator, allowing for reproducible random sequences.
+ * It provides methods for generating random numbers, integers, floating-point numbers within a range,
+ * random unit vectors, and random points within a bounding box or a specified range.
+ */
+export declare class Random {
+    private readonly _random;
+    constructor(seed: number);
+    set seed(value: number);
+    random(): number;
+    getInteger(): number;
+    getIntegerByMax(exclusiveMax: number): number;
+    intBetween(min: number, max: number): number;
+    floatBetween(min: number, max: number): number;
+    /**
+     * Generates a random number following a Gaussian (normal) distribution
+     * using the Box-Muller transform.
+     *
+     * @param mean - The mean (μ) of the distribution. Defaults to 0.
+     * @param stdDev - The standard deviation (σ) of the distribution. Defaults to 1.
+     * @returns A random number sampled from the specified normal distribution.
+     */
+    getGaussian(mean?: number, stdDev?: number): number;
+    getColor(): Color;
+    getColorStringByRandomHue(): string;
+    getUnitVector(): Vector3;
+    getPointInsideBox(boundingBox: Box3): Vector3;
+    getPoint(minCoordinate: number, maxCoordinate: number): Vector3;
+    getPointsInsideBox(count: number, boundingBox: Box3): Vector3[];
+}

package/dist/foundation/utilities/misc/defaultPolygonOffset.d.ts

@@ -0,0 +1,7 @@
+import { MeshPhongMaterial } from 'three';
+export declare const DEFAULT_POLYGON_OFFSET: {
+    polygonOffset: boolean;
+    polygonOffsetFactor: number;
+    polygonOffsetUnits: number;
+};
+export declare function updatePolygonOffset(material: MeshPhongMaterial, polygonOffset?: boolean): void;

package/dist/foundation/utilities/misc/defaultPolygonOffset.js

@@ -0,0 +1,11 @@
+//#region libs/shared/reveal-components/src/foundation/utilities/misc/defaultPolygonOffset.ts
+var e = {
+	polygonOffset: !0,
+	polygonOffsetFactor: 1,
+	polygonOffsetUnits: 4
+};
+function t(t, n = !0) {
+	t.polygonOffset = n, n && (t.polygonOffsetFactor = e.polygonOffsetFactor, t.polygonOffsetUnits = e.polygonOffsetUnits);
+}
+//#endregion
+export { e as DEFAULT_POLYGON_OFFSET, t as updatePolygonOffset };

package/dist/foundation/utilities/misc/incrementSignal.d.ts

@@ -0,0 +1,8 @@
+import { Signal } from '@cognite/signal-utils';
+/**
+ * Increments the value of a numeric signal by 1. This is useful for triggering changes in a class,
+ * where each of the properties doesn't have their own signal.
+ *
+ * @param signal - The signal containing a number value to increment
+ */
+export declare function incrementSignal(signal: Signal<number>): void;

package/dist/foundation/utilities/misc/incrementSignal.js

@@ -0,0 +1,6 @@
+//#region libs/shared/reveal-components/src/foundation/utilities/misc/incrementSignal.ts
+function e(e) {
+	e(e.peek() + 1);
+}
+//#endregion
+export { e as incrementSignal };

package/dist/foundation/utilities/misc/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(delay: number): Promise<void>;

package/dist/foundation/utilities/misc/typeGuards.d.ts

@@ -0,0 +1,5 @@
+import { AnyIntersection, Image360ClusterIntersection } from '@cognite/reveal';
+/**
+ * Type guard to check if an intersection is an Image360 Cluster Intersection.
+ */
+export declare function isImage360ClusterIntersection(intersection: AnyIntersection): intersection is Image360ClusterIntersection;

package/dist/foundation/utilities/misc/typeGuards.js

@@ -0,0 +1,6 @@
+//#region libs/shared/reveal-components/src/foundation/utilities/misc/typeGuards.ts
+function e(e) {
+	return e.type === "image360Cluster";
+}
+//#endregion
+export { e as isImage360ClusterIntersection };

package/dist/foundation/utilities/primitives/Box.d.ts

@@ -0,0 +1,34 @@
+import { Box3, Euler, Matrix4, Ray, Vector3 } from 'three';
+import { Primitive } from './Primitive';
+import { PrimitiveType } from './PrimitiveType';
+export declare class Box extends Primitive {
+    static MinSize: number;
+    readonly size: Vector3;
+    readonly center: Vector3;
+    readonly rotation: Euler;
+    get primitiveType(): PrimitiveType;
+    get diagonal(): number;
+    get area(): number;
+    get volume(): number;
+    getMatrix(): Matrix4;
+    setMatrix(matrix: Matrix4): void;
+    expandBoundingBox(boundingBox: Box3): void;
+    isPointInside(point: Vector3, globalMatrix: Matrix4): boolean;
+    intersectRay(ray: Ray, globalMatrix: Matrix4): Vector3 | undefined;
+    get hasHorizontalArea(): boolean;
+    get hasArea(): boolean;
+    get hasVolume(): boolean;
+    get horizontalArea(): number;
+    get verticalArea(): number;
+    get hasXYRotation(): boolean;
+    get zRotationInDegrees(): number;
+    set zRotationInDegrees(value: number);
+    getRotationMatrix(matrix?: Matrix4): Matrix4;
+    getScaledMatrix(scale: Vector3, matrix?: Matrix4): Matrix4;
+    getRotationInDegrees(component: number): number;
+    getRotationAngleByComponent(component: number): number;
+    copy(box: Box): this;
+    clear(): void;
+    forceMinSize(): void;
+    static isValidSize(value: number): boolean;
+}