@cognite/reveal-components 1.0.0

package/dist/foundation/utilities/primitives/Box.js

@@ -0,0 +1,101 @@
+import { forceAngleAround0 as e, forceBetween0AndPi as t, forceBetween0AndTwoPi as n } from "../extensions/mathUtils.js";
+import { PrimitiveType as r } from "./PrimitiveType.js";
+import { BoxUtils as i } from "./BoxUtils.js";
+import { Primitive as a } from "./Primitive.js";
+import { Euler as o, Matrix4 as s, Quaternion as c, Vector3 as l } from "three";
+import { degToRad as u, radToDeg as d } from "three/src/math/MathUtils.js";
+//#region libs/shared/reveal-components/src/foundation/utilities/primitives/Box.ts
+var f = class f extends a {
+	static MinSize = .01;
+	size = new l().setScalar(f.MinSize);
+	center = new l();
+	rotation = new o(0, 0, 0);
+	get primitiveType() {
+		return r.Box;
+	}
+	get diagonal() {
+		return this.size.length();
+	}
+	get area() {
+		return 2 * (this.size.x * this.size.y + this.size.y * this.size.z + this.size.z * this.size.x);
+	}
+	get volume() {
+		return this.size.x * this.size.y * this.size.z;
+	}
+	getMatrix() {
+		return this.getScaledMatrix(this.size);
+	}
+	setMatrix(e) {
+		let t = new c();
+		e.decompose(this.center, t, this.size), this.rotation.setFromQuaternion(t);
+	}
+	expandBoundingBox(e) {
+		i.expandBoundingBox(e, this.getMatrix());
+	}
+	isPointInside(e, t) {
+		let n = this.getMatrix();
+		return n.premultiply(t), i.createOrientedBox(n).containsPoint(e);
+	}
+	intersectRay(e, t) {
+		let n = this.getMatrix();
+		return n.premultiply(t), i.createOrientedBox(n).intersectRay(e, new l()) ?? void 0;
+	}
+	get hasHorizontalArea() {
+		let { size: e } = this;
+		return f.isValidSize(e.x) && f.isValidSize(e.y);
+	}
+	get hasArea() {
+		let { size: e } = this, t = 0;
+		return f.isValidSize(e.x) && t++, f.isValidSize(e.y) && t++, f.isValidSize(e.z) && t++, t >= 2;
+	}
+	get hasVolume() {
+		let { size: e } = this;
+		return f.isValidSize(e.x) && f.isValidSize(e.y) && f.isValidSize(e.z);
+	}
+	get horizontalArea() {
+		return this.size.x * this.size.y;
+	}
+	get verticalArea() {
+		return this.size.x * this.size.z;
+	}
+	get hasXYRotation() {
+		return this.rotation.x !== 0 || this.rotation.y !== 0;
+	}
+	get zRotationInDegrees() {
+		let e = this.hasXYRotation ? n(this.rotation.z) : t(this.rotation.z);
+		return d(e);
+	}
+	set zRotationInDegrees(e) {
+		this.rotation.z = u(e);
+	}
+	getRotationMatrix(e = new s()) {
+		return e.identity(), e.makeRotationFromEuler(this.rotation);
+	}
+	getScaledMatrix(e, t = new s()) {
+		return t.identity(), t.makeRotationFromEuler(this.rotation), t.setPosition(this.center), t.scale(e);
+	}
+	getRotationInDegrees(t) {
+		return t === 2 ? this.zRotationInDegrees : d(e(this.getRotationAngleByComponent(t)));
+	}
+	getRotationAngleByComponent(e) {
+		if (e === 0) return this.rotation.x;
+		if (e === 1) return this.rotation.y;
+		if (e === 2) return this.rotation.z;
+		throw Error("Invalid component: " + e);
+	}
+	copy(e) {
+		return this.size.copy(e.size), this.center.copy(e.center), this.rotation.copy(e.rotation), this;
+	}
+	clear() {
+		this.size.setScalar(f.MinSize), this.center.setScalar(0), this.rotation.set(0, 0, 0);
+	}
+	forceMinSize() {
+		let { size: e } = this;
+		e.x = Math.max(f.MinSize, e.x), e.y = Math.max(f.MinSize, e.y), e.z = Math.max(f.MinSize, e.z);
+	}
+	static isValidSize(e) {
+		return e > f.MinSize;
+	}
+};
+//#endregion
+export { f as Box };

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

@@ -0,0 +1,12 @@
+import { Vector3, BufferGeometry, Matrix4, Box3, BoxGeometry } from 'three';
+import { LineSegmentsGeometry } from 'three/examples/jsm/lines/LineSegmentsGeometry.js';
+import { OBB } from 'three/examples/jsm/math/OBB.js';
+export declare const CUBE_CORNERS: Vector3[];
+export declare class BoxUtils {
+    static createUnitGeometry(): BoxGeometry;
+    static expandBoundingBox(boundingBox: Box3, matrix: Matrix4): void;
+    static createOrientedBox(matrix: Matrix4): OBB;
+    static createLineSegmentsGeometry(): LineSegmentsGeometry;
+    static createPositions(): number[];
+    static createLineSegmentsBufferGeometry(): BufferGeometry;
+}

package/dist/foundation/utilities/primitives/BoxUtils.js

@@ -0,0 +1,72 @@
+import { getCorners as e } from "../geometry/getCorners.js";
+import { PrimitiveUtils as t } from "./PrimitiveUtils.js";
+import { Box3 as n, BoxGeometry as r, Vector3 as i } from "three";
+import { OBB as a } from "three/examples/jsm/math/OBB.js";
+//#region libs/shared/reveal-components/src/foundation/utilities/primitives/BoxUtils.ts
+var o = .5, s = l(), c = class e {
+	static createUnitGeometry() {
+		return new r(1, 1, 1);
+	}
+	static expandBoundingBox(e, t) {
+		let n = new i();
+		for (let r of s) n.copy(r), n.applyMatrix4(t), e.expandByPoint(n);
+	}
+	static createOrientedBox(e) {
+		let t = new a(new i(), new i().setScalar(o));
+		return t.applyMatrix4(e), t;
+	}
+	static createLineSegmentsGeometry() {
+		let n = e.createPositions();
+		return t.createLineSegmentsGeometryByPosition(n);
+	}
+	static createPositions() {
+		let e = s.flatMap((e) => [
+			e.x,
+			e.y,
+			e.z
+		]), n = [
+			0,
+			1,
+			1,
+			2,
+			2,
+			3,
+			3,
+			0
+		], r = [
+			4,
+			5,
+			5,
+			6,
+			6,
+			7,
+			7,
+			4
+		], i = [
+			0,
+			4,
+			1,
+			5,
+			2,
+			6,
+			3,
+			7
+		], a = [
+			...n,
+			...r,
+			...i
+		];
+		return t.createLineSegmentsAsPositions(e, a);
+	}
+	static createLineSegmentsBufferGeometry() {
+		let n = e.createPositions();
+		return t.createBufferGeometry(n);
+	}
+};
+function l() {
+	let t = new n(new i().setScalar(-.5), new i().setScalar(o)), r = [];
+	for (let n of e(t)) r.push(n.clone());
+	return r;
+}
+//#endregion
+export { c as BoxUtils, s as CUBE_CORNERS };

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

@@ -0,0 +1,39 @@
+import { Box3, Matrix4, Quaternion, Ray, Vector3 } from 'three';
+import { Primitive } from './Primitive';
+import { PrimitiveType } from './PrimitiveType';
+export declare class Cylinder extends Primitive {
+    static MinSize: number;
+    static HalfMinSize: number;
+    radius: number;
+    readonly centerA: Vector3;
+    readonly centerB: Vector3;
+    private readonly _center;
+    private readonly _axis;
+    private readonly _size;
+    get endCapArea(): number;
+    get primitiveType(): PrimitiveType;
+    get area(): number;
+    get volume(): number;
+    get diagonal(): number;
+    getMatrix(): Matrix4;
+    setMatrix(matrix: Matrix4): void;
+    expandBoundingBox(boundingBox: Box3): void;
+    isPointInside(point: Vector3, globalMatrix: Matrix4): boolean;
+    getPointsInside(points: Vector3[]): Vector3[];
+    intersectRay(ray: Ray, globalMatrix: Matrix4): Vector3 | undefined;
+    get height(): number;
+    set height(value: number);
+    get center(): Vector3;
+    get size(): Vector3;
+    get axis(): Vector3;
+    get diameter(): number;
+    getRotationMatrix(matrix?: Matrix4): Matrix4;
+    getScaledMatrix(scale: Vector3, matrix?: Matrix4): Matrix4;
+    getQuaternion(): Quaternion;
+    private getCenters;
+    copy(cylinder: Cylinder): this;
+    applyMatrix4(matrix: Matrix4): this;
+    clear(): void;
+    forceMinSize(): void;
+    static isValidSize(value: number): boolean;
+}

package/dist/foundation/utilities/primitives/Cylinder.js

@@ -0,0 +1,123 @@
+import { isEqual as e, square as t } from "../extensions/mathUtils.js";
+import { PrimitiveType as n } from "./PrimitiveType.js";
+import { Primitive as r } from "./Primitive.js";
+import { Range3 as i } from "../geometry/Range3.js";
+import { Line3 as a, Matrix4 as o, Quaternion as s, Vector3 as c } from "three";
+//#region libs/shared/reveal-components/src/foundation/utilities/primitives/Cylinder.ts
+var l = new c(0, 0, 1), u = class u extends r {
+	static MinSize = .01;
+	static HalfMinSize = u.MinSize * .5;
+	radius = u.MinSize;
+	centerA = new c(0, 0, -u.HalfMinSize);
+	centerB = new c(0, 0, +u.HalfMinSize);
+	_center = new c();
+	_axis = new c();
+	_size = new c();
+	get endCapArea() {
+		return Math.PI * this.radius * this.radius;
+	}
+	get primitiveType() {
+		return n.Cylinder;
+	}
+	get area() {
+		return 2 * Math.PI * this.radius * this.height + 2 * this.endCapArea;
+	}
+	get volume() {
+		return Math.PI * t(this.radius) * this.height;
+	}
+	get diagonal() {
+		return Math.sqrt(t(this.radius) + t(this.height));
+	}
+	getMatrix() {
+		return new o().compose(this.center, this.getQuaternion(), this.size);
+	}
+	setMatrix(e) {
+		let t = new c(0, 0, -.5).applyMatrix4(e), n = new c(0, 0, .5).applyMatrix4(e), r = new c().setFromMatrixScale(e);
+		this.centerA.copy(t), this.centerB.copy(n), this.radius = r.x / 2;
+	}
+	expandBoundingBox(e) {
+		let t = new i(this.centerA, this.centerB);
+		t.expandByMargin3(i.getCircleRangeMargin(this.axis, this.radius)), e.union(t.getBox());
+	}
+	isPointInside(e, t) {
+		let { centerA: n, centerB: r } = this.getCenters(t), i = new c().addVectors(n, r).divideScalar(2), a = n.sub(r), o = a.length();
+		a.normalize();
+		let s = i.sub(e), l = a.dot(s);
+		return a.multiplyScalar(l), a.sub(s), !(a.length() > this.radius || Math.abs(l) > o / 2);
+	}
+	getPointsInside(e) {
+		let t = new a(this.centerA, this.centerB), n = new c();
+		return e.filter((e) => {
+			let r = t.closestPointToPointParameter(e, !1);
+			return !(r < 0 || r > 1 || t.at(r, n).distanceTo(e) > this.radius);
+		});
+	}
+	intersectRay(e, t) {
+		let { centerA: n, centerB: r } = this.getCenters(t), { radius: i } = this, a = e.origin, o = e.direction, s = new c().subVectors(r, n), l = s.dot(o);
+		if (l > 0) {
+			let t = (s.dot(n) - s.dot(a)) / l, r = e.at(t, new c());
+			if (r.distanceTo(n) <= i) return r;
+		}
+		if (l < 0) {
+			let t = (s.dot(r) - s.dot(a)) / l, n = e.at(t, new c());
+			if (n.distanceTo(r) <= i) return n;
+		}
+		let u = new c().subVectors(a, n), d = s.dot(s), f = s.dot(u), p = d - l * l, m = d * u.dot(o) - f * l, h = d * u.dot(u) - f * f - i * i * d, g = m * m - p * h;
+		if (g < 0) return;
+		let _ = Math.sqrt(g), v = (-m - _) / p, y = f + v * l;
+		if (y > 0 && y < d) return e.at(v, new c());
+	}
+	get height() {
+		return this.centerA.distanceTo(this.centerB);
+	}
+	set height(e) {
+		let t = this.center, n = e * .5, r = this.axis;
+		this.centerA.copy(t).addScaledVector(r, -n), this.centerB.copy(t).addScaledVector(r, +n);
+	}
+	get center() {
+		return this._center.addVectors(this.centerB, this.centerA).divideScalar(2);
+	}
+	get size() {
+		return this._size.set(this.diameter, this.diameter, this.height);
+	}
+	get axis() {
+		return this._axis.subVectors(this.centerB, this.centerA).normalize();
+	}
+	get diameter() {
+		return 2 * this.radius;
+	}
+	getRotationMatrix(e = new o()) {
+		return e.identity(), e.makeRotationFromQuaternion(this.getQuaternion());
+	}
+	getScaledMatrix(e, t = new o()) {
+		return t.compose(this.center, this.getQuaternion(), e);
+	}
+	getQuaternion() {
+		return new s().setFromUnitVectors(l, this.axis);
+	}
+	getCenters(e) {
+		let t = this.centerA.clone(), n = this.centerB.clone();
+		return t.applyMatrix4(e), n.applyMatrix4(e), {
+			centerA: t,
+			centerB: n
+		};
+	}
+	copy(e) {
+		return this.radius = e.radius, this.centerA.copy(e.centerA), this.centerB.copy(e.centerB), this;
+	}
+	applyMatrix4(t) {
+		let n = new c().setFromMatrixScale(t);
+		return (!e(n.x, n.y) || !e(n.x, n.z)) && console.warn("Cylinder.applyMatrix4: The matrix has non-uniform scale, result may be incorrect."), this.centerA.applyMatrix4(t), this.centerB.applyMatrix4(t), this.radius *= n.x, this;
+	}
+	clear() {
+		this.radius = u.MinSize, this.centerA.set(0, 0, -u.HalfMinSize), this.centerB.set(0, 0, +u.HalfMinSize);
+	}
+	forceMinSize() {
+		this.radius = Math.max(this.radius, u.MinSize);
+	}
+	static isValidSize(e) {
+		return e > u.MinSize;
+	}
+};
+//#endregion
+export { u as Cylinder };

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

@@ -0,0 +1,8 @@
+import { BufferGeometry, CylinderGeometry } from 'three';
+import { LineSegmentsGeometry } from 'three/examples/jsm/lines/LineSegmentsGeometry.js';
+export declare class CylinderUtils {
+    static createUnitGeometry(): CylinderGeometry;
+    static createLineSegmentsGeometry(): LineSegmentsGeometry;
+    static createPositions(): number[];
+    static createLineSegmentsBufferGeometry(): BufferGeometry;
+}

package/dist/foundation/utilities/primitives/CylinderUtils.js

@@ -0,0 +1,34 @@
+import { PrimitiveUtils as e } from "./PrimitiveUtils.js";
+import { CylinderGeometry as t } from "three";
+//#region libs/shared/reveal-components/src/foundation/utilities/primitives/CylinderUtils.ts
+var n = .5, r = 5, i = 30, a = class a {
+	static createUnitGeometry() {
+		return new t(n, n, 1, i);
+	}
+	static createLineSegmentsGeometry() {
+		let t = a.createPositions();
+		return e.createLineSegmentsGeometryByPosition(t);
+	}
+	static createPositions() {
+		let t = 2 * Math.PI / i, a = [];
+		for (let e = 0; e <= i; e++) {
+			let r = e * t;
+			a.push(n * Math.sin(r)), a.push(n * Math.cos(r)), a.push(-.5);
+		}
+		for (let e = 0; e <= i; e++) {
+			let r = e * t;
+			a.push(n * Math.sin(r)), a.push(n * Math.cos(r)), a.push(n);
+		}
+		let o = [];
+		for (let e = 0; e < i; e++) o.push(e, e + 1);
+		for (let e = 0; e < i; e++) o.push(e + 31, e + 1 + 31);
+		for (let e = 0; e < i; e += r) o.push(e, e + 31);
+		return e.createLineSegmentsAsPositions(a, o);
+	}
+	static createLineSegmentsBufferGeometry() {
+		let t = a.createPositions();
+		return e.createBufferGeometry(t);
+	}
+};
+//#endregion
+export { a as CylinderUtils };

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

@@ -0,0 +1,16 @@
+import { Box3, Ray, Vector3, Matrix4 } from 'three';
+import { PrimitiveType } from './PrimitiveType';
+export declare abstract class Primitive {
+    confidence: number | undefined;
+    label: string | undefined;
+    abstract get primitiveType(): PrimitiveType;
+    abstract get volume(): number;
+    abstract get area(): number;
+    abstract get diagonal(): number;
+    abstract getMatrix(): Matrix4;
+    abstract setMatrix(matrix: Matrix4): void;
+    abstract expandBoundingBox(boundingBox: Box3): void;
+    abstract isPointInside(point: Vector3, globalMatrix: Matrix4): boolean;
+    abstract intersectRay(ray: Ray, globalMatrix: Matrix4): Vector3 | undefined;
+    getBoundingBox(): Box3;
+}

package/dist/foundation/utilities/primitives/Primitive.js

@@ -0,0 +1,12 @@
+import { Box3 as e } from "three";
+//#region libs/shared/reveal-components/src/foundation/utilities/primitives/Primitive.ts
+var t = class {
+	confidence = void 0;
+	label = void 0;
+	getBoundingBox() {
+		let t = new e().makeEmpty();
+		return this.expandBoundingBox(t), t;
+	}
+};
+//#endregion
+export { t as Primitive };

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

@@ -0,0 +1,22 @@
+export declare enum PrimitiveType {
+    None = 0,
+    Point = 1,
+    Line = 2,
+    Polyline = 3,
+    Polygon = 4,
+    HorizontalArea = 5,
+    VerticalArea = 6,
+    Box = 7,
+    Cylinder = 8,
+    HorizontalCircle = 9,
+    HorizontalCylinder = 10,
+    VerticalCylinder = 11,
+    Diameter = 12,
+    PlaneX = 13,
+    PlaneY = 14,
+    PlaneZ = 15,
+    PlaneXY = 16
+}
+export declare const AlongAxisPlanePrimitiveTypes: PrimitiveType[];
+export declare const PlanePrimitiveTypes: PrimitiveType[];
+export declare function verifyPrimitiveType(legalTypes: PrimitiveType[], primitiveType: PrimitiveType): void;

package/dist/foundation/utilities/primitives/PrimitiveType.js

@@ -0,0 +1,14 @@
+//#region libs/shared/reveal-components/src/foundation/utilities/primitives/PrimitiveType.ts
+var e = /* @__PURE__ */ function(e) {
+	return e[e.None = 0] = "None", e[e.Point = 1] = "Point", e[e.Line = 2] = "Line", e[e.Polyline = 3] = "Polyline", e[e.Polygon = 4] = "Polygon", e[e.HorizontalArea = 5] = "HorizontalArea", e[e.VerticalArea = 6] = "VerticalArea", e[e.Box = 7] = "Box", e[e.Cylinder = 8] = "Cylinder", e[e.HorizontalCircle = 9] = "HorizontalCircle", e[e.HorizontalCylinder = 10] = "HorizontalCylinder", e[e.VerticalCylinder = 11] = "VerticalCylinder", e[e.Diameter = 12] = "Diameter", e[e.PlaneX = 13] = "PlaneX", e[e.PlaneY = 14] = "PlaneY", e[e.PlaneZ = 15] = "PlaneZ", e[e.PlaneXY = 16] = "PlaneXY", e;
+}({}), t = [
+	13,
+	14,
+	15
+];
+[...t];
+function n(e, t) {
+	if (!e.includes(t)) throw Error(`Invalid primitive type: ${t}`);
+}
+//#endregion
+export { t as AlongAxisPlanePrimitiveTypes, e as PrimitiveType, n as verifyPrimitiveType };

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

@@ -0,0 +1,8 @@
+import { BufferGeometry, Vector3 } from 'three';
+import { LineSegmentsGeometry } from 'three/examples/jsm/lines/LineSegmentsGeometry.js';
+export declare class PrimitiveUtils {
+    static createLineSegmentsAsPositions(positions: number[], indices: number[]): number[];
+    static createBufferGeometry(positions: number[]): BufferGeometry;
+    static createLineSegmentsGeometryByPosition(positions: number[]): LineSegmentsGeometry;
+    static createLineSegmentsGeometryByVertices(vertices: Vector3[]): LineSegmentsGeometry;
+}

package/dist/foundation/utilities/primitives/PrimitiveUtils.js

@@ -0,0 +1,27 @@
+import { BufferGeometry as e, Float32BufferAttribute as t, LineSegments as n } from "three";
+import { LineSegmentsGeometry as r } from "three/examples/jsm/lines/LineSegmentsGeometry.js";
+//#region libs/shared/reveal-components/src/foundation/utilities/primitives/PrimitiveUtils.ts
+var i = class i {
+	static createLineSegmentsAsPositions(e, t) {
+		let n = [];
+		for (let r = 0; r < t.length; r++) {
+			let i = 3 * t[r];
+			n.push(e[i], e[i + 1], e[i + 2]);
+		}
+		return n;
+	}
+	static createBufferGeometry(n) {
+		let r = new t(n, 3);
+		return new e().setAttribute("position", r);
+	}
+	static createLineSegmentsGeometryByPosition(e) {
+		let t = i.createBufferGeometry(e), a = new n(t);
+		return new r().fromLineSegments(a);
+	}
+	static createLineSegmentsGeometryByVertices(t) {
+		let i = new e().setFromPoints(t), a = new n(i);
+		return new r().fromLineSegments(a);
+	}
+};
+//#endregion
+export { i as PrimitiveUtils };

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

@@ -0,0 +1,7 @@
+import { Box3, Vector3 } from 'three';
+export declare class Vector3ArrayUtils {
+    static getSignedHorizontalArea(polygon: Vector3[]): number;
+    static getCenter(points: Vector3[]): Vector3 | undefined;
+    static getCenterOfMass(points: Vector3[]): Vector3 | undefined;
+    static getBoundingBox(points: Vector3[]): Box3 | undefined;
+}

package/dist/foundation/utilities/primitives/Vector3ArrayUtils.js

@@ -0,0 +1,31 @@
+import { getHorizontalCrossProduct as e } from "../extensions/vectorUtils.js";
+import { Box3 as t, Vector3 as n } from "three";
+//#region libs/shared/reveal-components/src/foundation/utilities/primitives/Vector3ArrayUtils.ts
+var r = class r {
+	static getSignedHorizontalArea(t) {
+		let r = t.length;
+		if (r < 3) return 0;
+		let i = 0, a = t[0], o = new n(), s = new n();
+		for (let n = 1; n <= r; n++) s.copy(t[n % r]), s.sub(a), i += e(o, s), o.copy(s);
+		return i / 2;
+	}
+	static getCenter(e) {
+		let t = r.getBoundingBox(e);
+		if (t !== void 0) return t.getCenter(new n());
+	}
+	static getCenterOfMass(e) {
+		let t = new n();
+		if (e.length !== 0) {
+			for (let n of e) t.add(n);
+			return t.divideScalar(e.length);
+		}
+	}
+	static getBoundingBox(e) {
+		if (e.length === 0) return;
+		let n = new t();
+		for (let t of e) n.expandByPoint(t);
+		return n;
+	}
+};
+//#endregion
+export { r as Vector3ArrayUtils };

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

@@ -0,0 +1,3 @@
+import { IconName } from '../types';
+import { PrimitiveType } from './PrimitiveType';
+export declare function getIconByPrimitiveType(primitiveType: PrimitiveType): IconName;

package/dist/foundation/utilities/primitives/getIconByPrimitiveType.js

@@ -0,0 +1,26 @@
+import { PrimitiveType as e } from "./PrimitiveType.js";
+//#region libs/shared/reveal-components/src/foundation/utilities/primitives/getIconByPrimitiveType.ts
+function t(t) {
+	switch (t) {
+		case e.Point: return "Point";
+		case e.Line: return "Line";
+		case e.Polyline: return "Polygon";
+		case e.Polygon: return "Perspective";
+		case e.PlaneX: return "CubeFrontLeft";
+		case e.PlaneY: return "CubeFrontRight";
+		case e.PlaneZ: return "CubeTop";
+		case e.PlaneXY: return "Perspective";
+		case e.HorizontalArea: return "PerspectiveAlt";
+		case e.VerticalArea: return "Perspective";
+		case e.Box: return "Cube";
+		case e.HorizontalCircle: return "Circle";
+		case e.Diameter: return "MeasurementDiameter";
+		case e.Cylinder: return "CylinderArbitrary";
+		case e.VerticalCylinder: return "CylinderVertical";
+		case e.HorizontalCylinder: return "CylinderHorizontal";
+		case e.None: return "Cursor";
+		default: throw Error("Unrecognized PrimitiveType");
+	}
+}
+//#endregion
+export { t as getIconByPrimitiveType };

package/dist/foundation/utilities/quality/QualitySettings.d.ts

@@ -0,0 +1,6 @@
+import { CadModelBudget, PointCloudBudget, ResolutionOptions } from '@cognite/reveal';
+export type QualitySettings = {
+    cadBudget: CadModelBudget;
+    pointCloudBudget: PointCloudBudget;
+    resolutionOptions: ResolutionOptions;
+};

package/dist/foundation/utilities/sprites/createSprite.d.ts

@@ -0,0 +1,26 @@
+import { Vector3, Color, Sprite } from 'three';
+/**
+ * Creates a sprite with the specified text.
+ *
+ * @param text - The text to be displayed on the sprite.
+ * @param worldHeight - The height of sprite in the world coordinates.
+ * @param color - The color of the text.
+ * @param bgColor - The background color of the sprite (optional).
+ * @returns The created sprite, or undefined if the canvas creation failed.
+ */
+export declare function createSpriteWithText(text: string, worldHeight: number, color: Color, bgColor?: Color): Sprite;
+/**
+ * Moves a sprite to a new position based on a given position and direction.
+ * @param sprite - The sprite to move.
+ * @param position - The current position of the sprite.
+ * @param direction - The direction in which the sprite should move.
+ */
+export declare function moveSpriteByPositionAndDirection(sprite: Sprite, position: Vector3, direction: Vector3): void;
+/**
+ * Moves a sprite to a specified position and aligns it based on the given alignment value.
+ * @param sprite - The sprite to be moved.
+ * @param position - The position to move the sprite to.
+ * @param alignment - The alignment value to align the sprite. This is a number between 0 and 8.
+ * and is documented below.
+ */
+export declare function moveSpriteByPositionAndAlignment(sprite: Sprite, position: Vector3, alignment: number): void;

package/dist/foundation/utilities/sprites/createSprite.js

@@ -0,0 +1,32 @@
+import { CanvasTexture as e, LinearFilter as t, NearestFilter as n, Sprite as r, SpriteMaterial as i } from "three";
+//#region libs/shared/reveal-components/src/foundation/utilities/sprites/createSprite.ts
+var a = "sans-serif";
+function o(e, t, n, r) {
+	return c(u(e, n, r), t);
+}
+function s(e, t, n) {
+	let r = n.clone();
+	r.multiply(e.scale), r.divideScalar(2), r.add(t), e.position.copy(r);
+}
+function c(e, t) {
+	let n = l(e), a = new i({ map: n }), o = new r(a);
+	return o.scale.set(t * e.width / e.height, t, 1), o;
+}
+function l(r) {
+	let i = new e(r);
+	return i.minFilter = t, i.magFilter = n, i.needsUpdate = !0, i;
+}
+function u(e, t, n) {
+	let r = f(60), i = document.createElement("canvas"), a = i.getContext("2d");
+	a !== null && (a.font = r);
+	let o = a === null ? e.length * 10 : a.measureText(e).width, s = o + 8;
+	return i.width = o + 8, i.height = 64, a === null ? i : (a.clearRect(0, 0, i.width, i.height), n !== void 0 && (a.fillStyle = "#" + n.getHexString(), a.beginPath(), a.roundRect(0, 0, s, 64, 10), a.fill()), a.font = r, a.textBaseline = "middle", a.textAlign = "center", a.translate(s / 2, 32), a.fillStyle = "#" + t.getHexString(), a.fillText(e, 0, 2), i);
+}
+function d(e) {
+	return `${e}px ${a}`;
+}
+function f(e) {
+	return `Normal ${d(e)}`;
+}
+//#endregion
+export { o as createSpriteWithText, s as moveSpriteByPositionAndDirection };

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

@@ -0,0 +1,14 @@
+import { default as english } from '../../../common/i18n/en/reveal-components.json';
+export type Translations = Record<string, string>;
+export type TranslationKey = keyof typeof english;
+export type TranslatedString = {
+    key: TranslationKey;
+};
+export type UntranslatedString = {
+    untranslated: string;
+};
+export type TranslationInput = TranslatedString | UntranslatedString;
+export declare function isEmpty(input: TranslationInput | undefined): boolean;
+export type TranslateDelegate = (input: TranslationInput) => string;
+export declare function isTranslatedString(input: TranslationInput): input is TranslatedString;
+export declare function isUntranslatedString(input: TranslationInput): input is UntranslatedString;

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

@@ -0,0 +1,8 @@
+import e from "../../../common/i18n/en/reveal-components.js";
+//#region libs/shared/reveal-components/src/foundation/utilities/translation/TranslateInput.ts
+function t(t) {
+	let n = t.key;
+	return n !== void 0 && n in e;
+}
+//#endregion
+export { t as isTranslatedString };