@cognite/reveal-components 1.0.0

package/dist/domains/terrain/TerrainRenderStyle.js

@@ -0,0 +1,24 @@
+import { ColorType as e } from "../../foundation/domainObjectsHelpers/ColorType.js";
+import { RenderStyle as t } from "../../foundation/renderStyles/RenderStyle.js";
+import { ColorMapType as n } from "../../foundation/utilities/colors/ColorMapType.js";
+import { cloneDeep as r } from "lodash-es";
+//#region libs/shared/reveal-components/src/domains/terrain/TerrainRenderStyle.ts
+var i = class extends t {
+	showContours = !0;
+	contoursColorType = e.Black;
+	showSolid = !0;
+	solidColorType = e.ColorMap;
+	solidColorMapType = n.Rainbow;
+	solidContourVolume = .5;
+	solidContourUse = !0;
+	solidShininess = .03;
+	solidShininessUse = !0;
+	solidOpacity = .5;
+	solidOpacityUse = !1;
+	increment = 0;
+	clone() {
+		return r(this);
+	}
+};
+//#endregion
+export { i as TerrainRenderStyle };

package/dist/domains/terrain/TerrainThreeView.d.ts

@@ -0,0 +1,13 @@
+import { Box3 } from 'three';
+import { DomainObjectChange } from '../../foundation/domainObjectsHelpers/DomainObjectChange';
+import { GroupThreeView } from '../../foundation/views/GroupThreeView';
+import { TerrainDomainObject } from './TerrainDomainObject';
+import { TerrainRenderStyle } from './TerrainRenderStyle';
+export declare class TerrainThreeView extends GroupThreeView<TerrainDomainObject> {
+    protected get style(): TerrainRenderStyle;
+    update(change: DomainObjectChange): void;
+    protected calculateBoundingBox(): Box3;
+    protected addChildren(): void;
+    private createSolid;
+    private createContours;
+}

package/dist/domains/terrain/TerrainThreeView.js

@@ -0,0 +1,85 @@
+import { Changes as e } from "../../foundation/domainObjectsHelpers/Changes.js";
+import { ColorType as t } from "../../foundation/domainObjectsHelpers/ColorType.js";
+import { WHITE_COLOR as n } from "../../foundation/utilities/colors/colorUtils.js";
+import { PrimitiveUtils as r } from "../../foundation/utilities/primitives/PrimitiveUtils.js";
+import { GroupThreeView as i } from "../../foundation/views/GroupThreeView.js";
+import { updatePolygonOffset as a } from "../../foundation/utilities/misc/defaultPolygonOffset.js";
+import { getColorMap as o } from "../../foundation/utilities/colors/colorMaps.js";
+import { create1DTexture as s, create1DTextureWithContours as c } from "../../foundation/utilities/colors/create1DTexture.js";
+import { ContouringService as l } from "./geometry/ContouringService.js";
+import { RegularGrid2Buffers as u } from "./geometry/RegularGrid2Buffers.js";
+import { DoubleSide as d, LineBasicMaterial as f, LineSegments as p, Mesh as m, MeshPhongMaterial as h } from "three";
+import { CDF_TO_VIEWER_TRANSFORMATION as g } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/domains/terrain/TerrainThreeView.ts
+var _ = "Solid", v = "Contour", y = class extends i {
+	get style() {
+		return super.style;
+	}
+	update(t) {
+		if (super.update(t), !this.isEmpty && (t.isChanged(e.colorMap) && (this.clearMemory(), this.invalidateRenderTarget()), t.isChanged(e.renderStyle))) {
+			let e = this.style;
+			{
+				let t = this.object.getObjectByName(_);
+				t !== void 0 && !e.showSolid ? (this.removeChild(t), this.invalidateRenderTarget()) : t === void 0 && e.showSolid ? (this.addChild(this.createSolid()), this.invalidateRenderTarget()) : t !== void 0 && (x(t.material, this.domainObject, e), this.invalidateRenderTarget());
+			}
+			{
+				let t = this.object.getObjectByName(v);
+				t !== void 0 && !e.showContours ? (this.removeChild(t), this.invalidateRenderTarget()) : t === void 0 && e.showContours ? (this.addChild(this.createContours()), this.invalidateRenderTarget()) : t !== void 0 && (S(t.material, this.domainObject, e), this.invalidateRenderTarget());
+			}
+		}
+	}
+	calculateBoundingBox() {
+		let e = this.domainObject.getBoundingBox();
+		return e.applyMatrix4(g), e;
+	}
+	addChildren() {
+		let { grid: e } = this.domainObject;
+		e !== void 0 && (this.addChild(this.createSolid()), this.addChild(this.createContours()));
+	}
+	createSolid() {
+		let { style: e } = this;
+		if (!e.showSolid) return;
+		let { domainObject: t } = this, { grid: n } = t;
+		if (n === void 0) return;
+		let r = new u(n, !0).createBufferGeometry(), i = new h();
+		x(i, t, e);
+		let a = new m(r, i);
+		return a.name = _, b(a, n), a;
+	}
+	createContours() {
+		let { style: e } = this;
+		if (!e.showContours) return;
+		let { domainObject: t } = this, { grid: n } = t;
+		if (n === void 0) return;
+		let i = new l(e.increment).createContoursAsPositions(n);
+		if (i.length === 0) return;
+		let a = r.createBufferGeometry(i), o = new f();
+		S(o, t, e);
+		let s = new p(a, o);
+		return s.name = v, b(s, n), s;
+	}
+};
+function b(e, t) {
+	e.rotateZ(t.rotationAngle), e.position.set(t.origin.x, t.origin.y, 0), e.applyMatrix4(g);
+}
+function x(e, t, r, i = !1) {
+	a(e, r.showContours), e.side = d, e.opacity = r.solidOpacityUse ? r.solidOpacity : 1, e.transparent = r.solidOpacityUse, e.shininess = i ? 0 : r.solidShininessUse ? 100 * r.solidShininess : 0, e.specular = n;
+	let o = C(t, r);
+	o === void 0 ? (e.map !== null && (e.map.dispose(), e.map = null), e.color = t.getColorByColorType(r.solidColorType)) : (o.anisotropy = 2, e.color = n, e.map = o);
+}
+function S(e, t, n) {
+	e.color = t.getColorByColorType(n.contoursColorType), e.linewidth = 1;
+}
+function C(e, n) {
+	if (n.solidColorType !== t.ColorMap && !n.solidContourUse) return;
+	let r = o(n.solidColorMapType);
+	if (r === void 0) return;
+	let i;
+	if (n.solidColorType === t.ColorMap) {
+		if (!n.solidContourUse) return s(r);
+	} else i = e.getColorByColorType(n.solidColorType);
+	let { grid: a } = e;
+	if (a !== void 0) return c(r, a.boundingBox.z, n.increment, n.solidContourVolume, i);
+}
+//#endregion
+export { y as TerrainThreeView };

package/dist/domains/terrain/geometry/ContouringService.d.ts

@@ -0,0 +1,12 @@
+import { RegularGrid2 } from './RegularGrid2';
+export declare class ContouringService {
+    private readonly _tempRange;
+    private readonly _increment;
+    private readonly _tolerance;
+    private readonly _positions;
+    constructor(increment: number);
+    createContoursAsPositions(grid: RegularGrid2): number[];
+    private addTriangle;
+    private addLevelAt;
+    private addLinearInterpolation;
+}

package/dist/domains/terrain/geometry/ContouringService.js

@@ -0,0 +1,39 @@
+import { isAbsEqual as e, isBetween as t } from "../../../foundation/utilities/extensions/mathUtils.js";
+import { Range1 as n } from "../../../foundation/utilities/geometry/Range1.js";
+import { Vector3 as r } from "three";
+//#region libs/shared/reveal-components/src/domains/terrain/geometry/ContouringService.ts
+var i = class {
+	_tempRange = new n();
+	_increment;
+	_tolerance;
+	_positions = [];
+	constructor(e) {
+		this._increment = e, this._tolerance = this._increment / 1e3;
+	}
+	createContoursAsPositions(e) {
+		let t = new r(), n = new r(), i = new r(), a = new r();
+		for (let r = 0; r < e.nodeSize.i - 1; r++) for (let o = 0; o < e.nodeSize.j - 1; o++) {
+			let s = e.getRelativeNodePosition(r + 0, o + 0, t), c = e.getRelativeNodePosition(r + 1, o + 0, n), l = e.getRelativeNodePosition(r + 1, o + 1, i), u = e.getRelativeNodePosition(r + 0, o + 1, a), d = 0;
+			s && (d += 1), l && (d += 1), l && (d += 1), u && (d += 1), !(d < 3) && (s || this.addTriangle(n, i, a), (d === 4 || !c) && this.addTriangle(t, i, a), l || this.addTriangle(t, n, a), (d === 4 || !u) && this.addTriangle(t, n, i));
+		}
+		return this._positions;
+	}
+	addTriangle(e, t, n) {
+		this._tempRange.set(Math.min(e.z, t.z, n.z), Math.max(e.z, t.z, n.z));
+		for (let r of this._tempRange.getFastTicks(this._increment, this._tolerance)) {
+			let i = Number(r);
+			this.addLevelAt(i, e, t, n);
+		}
+	}
+	addLevelAt(n, r, i, a) {
+		e(r.z, n, this._tolerance) && (r.z = n + this._tolerance), e(i.z, n, this._tolerance) && (i.z = n + this._tolerance), e(a.z, n, this._tolerance) && (a.z = n + this._tolerance), e(r.z, i.z, this._tolerance) && (i.z = r.z + this._tolerance);
+		let o = t(r.z, n, i.z), s = t(i.z, n, a.z), c = t(a.z, n, r.z), l = 0;
+		return o && l++, s && l++, c && l++, l === 2 && (o && this.addLinearInterpolation(r, i, n), s && this.addLinearInterpolation(i, a, n), c && this.addLinearInterpolation(a, r, n), !0);
+	}
+	addLinearInterpolation(e, t, n) {
+		let r = (n - e.z) / (t.z - e.z);
+		this._positions.push((t.x - e.x) * r + e.x, (t.y - e.y) * r + e.y, n);
+	}
+};
+//#endregion
+export { i as ContouringService };

package/dist/domains/terrain/geometry/Grid2.d.ts

@@ -0,0 +1,14 @@
+import { Index2 } from '../../../foundation/utilities/geometry/Index2';
+import { Range3 } from '../../../foundation/utilities/geometry/Range3';
+import { Shape } from '../../../foundation/utilities/geometry/Shape';
+export declare class Grid2 extends Shape {
+    readonly nodeSize: Index2;
+    readonly cellSize: Index2;
+    constructor(nodeSize: Index2);
+    clone(): Shape;
+    expandBoundingBox(_: Range3): void;
+    getNodeIndex(i: number, j: number): number;
+    getCellIndex(i: number, j: number): number;
+    isNodeInside(i: number, j: number): boolean;
+    isCellInside(i: number, j: number): boolean;
+}

package/dist/domains/terrain/geometry/RegularGrid2.d.ts

@@ -0,0 +1,36 @@
+import { Vector2, Vector3 } from 'three';
+import { Index2 } from '../../../foundation/utilities/geometry/Index2';
+import { Range1 } from '../../../foundation/utilities/geometry/Range1';
+import { Range3 } from '../../../foundation/utilities/geometry/Range3';
+import { Shape } from '../../../foundation/utilities/geometry/Shape';
+import { Grid2 } from './Grid2';
+export declare class RegularGrid2 extends Grid2 {
+    readonly origin: Vector2;
+    readonly increment: Vector2;
+    private _buffer;
+    private _hasRotationAngle;
+    private _rotationAngle;
+    private _sinRotationAngle;
+    private _cosRotationAngle;
+    static _tempVectorA: Vector3;
+    static _tempVectorB: Vector3;
+    get rotationAngle(): number;
+    set rotationAngle(value: number);
+    constructor(nodeSize: Index2, origin: Vector2, increment: Vector2, rotationAngle?: number | undefined);
+    toString(): string;
+    clone(): Shape;
+    expandBoundingBox(boundingBox: Range3): void;
+    isNodeDef(i: number, j: number): boolean;
+    isNodeInsideDef(i: number, j: number): boolean;
+    getZ(i: number, j: number): number;
+    getNodePosition(i: number, j: number, resultPosition?: Vector3): boolean;
+    getNodePosition2(i: number, j: number, resultPosition: Vector3): void;
+    getRelativeNodePosition(i: number, j: number, resultPosition: Vector3): boolean;
+    getCellFromPosition(position: Vector3, resultCell?: Index2): Index2;
+    getNormal(i: number, j: number, z: number | undefined, normalize: boolean, resultNormal?: Vector3): Vector3;
+    getCornerRange(): Range3;
+    setNodeUndef(i: number, j: number): void;
+    setZ(i: number, j: number, value: number): void;
+    normalizeZ(wantedRange?: Range1): void;
+    smoothSimple(numberOfPasses?: number): void;
+}

package/dist/domains/terrain/geometry/RegularGrid2Buffers.d.ts

@@ -0,0 +1,8 @@
+import { TrianglesBuffers } from '../../../foundation/utilities/geometry/TrianglesBuffers';
+import { RegularGrid2 } from './RegularGrid2';
+export declare class RegularGrid2Buffers extends TrianglesBuffers {
+    constructor(grid: RegularGrid2, makeUvs: boolean);
+    makeBuffers(grid: RegularGrid2, uniqueIndexes: number[]): void;
+    private makeTriangleIndexes;
+    private static createUniqueIndexes;
+}

package/dist/domains/terrain/geometry/RegularGrid2Buffers.js

@@ -0,0 +1,39 @@
+import { TrianglesBuffers as e } from "../../../foundation/utilities/geometry/TrianglesBuffers.js";
+import { Vector3 as t } from "three";
+//#region libs/shared/reveal-components/src/domains/terrain/geometry/RegularGrid2Buffers.ts
+var n = class n extends e {
+	constructor(e, t) {
+		let [r, i] = n.createUniqueIndexes(e);
+		super(i, !0, t), this.makeBuffers(e, r), this.makeTriangleIndexes(e, r);
+	}
+	makeBuffers(e, n) {
+		let { zRange: r } = e, i = new t(), a = new t();
+		for (let t = e.nodeSize.j - 1; t >= 0; t--) for (let o = e.nodeSize.i - 1; o >= 0; o--) {
+			let s = n[e.getNodeIndex(o, t)];
+			if (s < 0 || !e.getRelativeNodePosition(o, t, i)) continue;
+			e.getNormal(o, t, i.z, !0, a);
+			let c = r.getFraction(i.z);
+			this.setAt(s, i, a, c);
+		}
+	}
+	makeTriangleIndexes(e, t) {
+		for (let n = 0; n < e.nodeSize.i - 1; n++) for (let r = 0; r < e.nodeSize.j - 1; r++) {
+			let i = e.getNodeIndex(n, r), a = e.getNodeIndex(n + 1, r), o = e.getNodeIndex(n + 1, r + 1), s = e.getNodeIndex(n, r + 1), c = t[i], l = t[a], u = t[o], d = t[s], f = 0;
+			c >= 0 && (f += 1), l >= 0 && (f += 1), u >= 0 && (f += 1), d >= 0 && (f += 1), !(f < 3) && (c < 0 && this.addTriangle(l, u, d), (f === 4 || l < 0) && this.addTriangle(c, u, d), u < 0 && this.addTriangle(c, l, d), (f === 4 || d < 0) && this.addTriangle(c, l, u));
+		}
+	}
+	static createUniqueIndexes(e) {
+		let t = Array(e.nodeSize.size), n = 0;
+		for (let r = e.nodeSize.j - 1; r >= 0; r--) for (let i = e.nodeSize.i - 1; i >= 0; i--) {
+			let a = e.getNodeIndex(i, r);
+			if (!e.isNodeDef(i, r)) {
+				t[a] = -1;
+				continue;
+			}
+			t[a] = n, n += 1;
+		}
+		return [t, n];
+	}
+};
+//#endregion
+export { n as RegularGrid2Buffers };

package/dist/domains/terrain/geometry/createFractalRegularGrid2.d.ts

@@ -0,0 +1,4 @@
+import { Range3 } from '../../../foundation/utilities/geometry/Range3';
+import { Random } from '../../../foundation/utilities/misc/Random';
+import { RegularGrid2 } from './RegularGrid2';
+export declare function createFractalRegularGrid2(boundingBox: Range3, random: Random, powerOf2?: number, damping?: number, smoothNumberOfPasses?: number, rotationAngle?: number): RegularGrid2;

package/dist/foundation/commands/BaseBannerCommand.d.ts

@@ -0,0 +1,16 @@
+import { TranslationInput } from '../utilities/translation/TranslateInput';
+import { RenderTargetCommand } from './RenderTargetCommand';
+export declare enum BannerStatus {
+    Critical = "critical",
+    Neutral = "neutral",
+    Success = "success",
+    Warning = "warning"
+}
+/**
+ * Base class for all option like commands. Override createOptions to add options
+ * or use add method to add them in.
+ */
+export declare abstract class BaseBannerCommand extends RenderTargetCommand {
+    abstract get content(): TranslationInput;
+    get status(): BannerStatus;
+}

package/dist/foundation/commands/BaseBannerCommand.js

@@ -0,0 +1,11 @@
+import { RenderTargetCommand as e } from "./RenderTargetCommand.js";
+//#region libs/shared/reveal-components/src/foundation/commands/BaseBannerCommand.ts
+var t = /* @__PURE__ */ function(e) {
+	return e.Critical = "critical", e.Neutral = "neutral", e.Success = "success", e.Warning = "warning", e;
+}({}), n = class extends e {
+	get status() {
+		return "neutral";
+	}
+};
+//#endregion
+export { t as BannerStatus, n as BaseBannerCommand };

package/dist/foundation/commands/BaseCommand.d.ts

@@ -0,0 +1,88 @@
+import { Signal } from '@cognite/signal-utils';
+import { TranslationInput } from '../utilities/translation/TranslateInput';
+import { IconName, ButtonType, UniqueId } from '../utilities/types';
+/**
+ * Represents a delegate function for updating a command.
+ *
+ * @param command - The command to be updated.
+ * @param change - An optional symbol representing the change made to the command.
+ * if not set, anything can be changed. See changes is CommandChanges for common legal changes.
+ */
+export type CommandUpdateDelegate = (command: BaseCommand, change?: symbol) => void;
+/**
+ * Base class for all command and tools. These are object that can do a
+ * user interaction with the system. It also have enough information to
+ * generate the UI for the command.
+ */
+export declare abstract class BaseCommand {
+    private readonly _listeners;
+    private readonly _disposables;
+    get disposableCount(): number;
+    private readonly _uniqueId;
+    get uniqueId(): UniqueId;
+    constructor();
+    get name(): string;
+    protected get shortCutKey(): string | undefined;
+    protected get shortCutKeyOnCtrl(): boolean;
+    protected get shortCutKeyOnAlt(): boolean;
+    protected get shortCutKeyOnShift(): boolean;
+    get tooltip(): TranslationInput | undefined;
+    get icon(): IconName;
+    get buttonType(): ButtonType;
+    get isEnabled(): boolean;
+    get isVisible(): boolean;
+    /**
+     * Gets a value indicating whether the command can be toggled on or off.
+     * Override this property if the command can be toggled.
+     * You must also override isChecked to get the toggle state.
+     */
+    get isToggle(): boolean;
+    get isChecked(): boolean;
+    /**
+     * Gets a value indicating whether the command has data, for instance a reference
+     * to a specific domain object. Then the command cannot be reused or shared in the user interface.
+     * These command will not be added to the commandsController for updating, so update will
+     * not be done automatically. Typically used when the command is created for a specific domain object
+     * in the DomainObjectPanel.
+     */
+    get hasData(): boolean;
+    /**
+     * Gets the direct children of this command in the command hierarchy.
+     *
+     * @remarks
+     * This generator method allows commands to form a parent-child hierarchy.
+     * By default, it returns no children (empty generator). Override this method
+     * in derived classes to yield child commands if your command contains sub-commands.
+     *
+     * Child commands will automatically receive:
+     * - `dispose()` calls when the parent is disposed
+     * - `update()` calls when the parent is updated
+     *
+     * Use `getDescendants()` to retrieve all descendants (children, grandchildren, etc.) recursively.
+     *
+     * @yields {BaseCommand} Direct child commands of this command
+     *
+     */
+    protected getChildren(): Generator<BaseCommand>;
+    getDescendants(): Generator<BaseCommand>;
+    protected invokeCore(): boolean;
+    equals(other: BaseCommand): boolean;
+    invoke(): boolean;
+    /**
+     * Removes the core functionality of the command
+     * This method should be overridden in derived classes to provide custom implementation.
+     * @remarks
+     * Always call `super.dispose()` in the overrides.
+     */
+    dispose(): void;
+    addEventListener(listener: CommandUpdateDelegate): void;
+    removeEventListener(listener: CommandUpdateDelegate): void;
+    removeEventListeners(): void;
+    update(change?: symbol): void;
+    get label(): string;
+    protected addDisposable(disposable: () => void): void;
+    protected addEffect(effectFunction: () => void): void;
+    protected listenTo<T>(signal: Signal<T>): void;
+    getShortCutKeys(): string[] | undefined;
+    hasShortCutKey(key: string, ctrl: boolean, shift: boolean, alt: boolean): boolean;
+}

package/dist/foundation/commands/BaseCommand.js

@@ -0,0 +1,112 @@
+import { isTranslatedString as e } from "../utilities/translation/TranslateInput.js";
+import { translate as t } from "../utilities/translation/translateUtils.js";
+import { clear as n, remove as r } from "../utilities/extensions/arrayUtils.js";
+import { isMacOs as i } from "../utilities/extensions/isMacOs.js";
+import { generateUniqueId as a } from "../utilities/types.js";
+import { effect as o } from "@cognite/signal-utils";
+//#region libs/shared/reveal-components/src/foundation/commands/BaseCommand.ts
+var s = class {
+	_listeners = [];
+	_disposables = [];
+	get disposableCount() {
+		return this._disposables.length;
+	}
+	_uniqueId;
+	get uniqueId() {
+		return this._uniqueId;
+	}
+	constructor() {
+		this._uniqueId = a();
+	}
+	get name() {
+		return this.tooltip === void 0 ? "" : e(this.tooltip) ? this.tooltip.key : this.tooltip?.untranslated;
+	}
+	get shortCutKey() {}
+	get shortCutKeyOnCtrl() {
+		return !1;
+	}
+	get shortCutKeyOnAlt() {
+		return !1;
+	}
+	get shortCutKeyOnShift() {
+		return !1;
+	}
+	get tooltip() {}
+	get icon() {}
+	get buttonType() {
+		return "default";
+	}
+	get isEnabled() {
+		return !0;
+	}
+	get isVisible() {
+		return this.isEnabled;
+	}
+	get isToggle() {
+		return !1;
+	}
+	get isChecked() {
+		return !1;
+	}
+	get hasData() {
+		return !1;
+	}
+	*getChildren() {}
+	*getDescendants() {
+		for (let e of this.getChildren()) yield e, yield* e.getDescendants();
+	}
+	invokeCore() {
+		return !1;
+	}
+	equals(e) {
+		return this.constructor === e.constructor;
+	}
+	invoke() {
+		return this.invokeCore();
+	}
+	dispose() {
+		for (let e of this.getChildren()) e.dispose();
+		for (let e of this._disposables) e();
+		n(this._disposables), this.removeEventListeners();
+	}
+	addEventListener(e) {
+		this._listeners.push(e);
+	}
+	removeEventListener(e) {
+		r(this._listeners, e);
+	}
+	removeEventListeners() {
+		n(this._listeners);
+	}
+	update(e) {
+		for (let t of this._listeners) t(this, e);
+		for (let t of this.getChildren()) t.update(e);
+	}
+	get label() {
+		return this.tooltip === void 0 ? "" : t(this.tooltip);
+	}
+	addDisposable(e) {
+		this._disposables.push(e);
+	}
+	addEffect(e) {
+		this.addDisposable(o(() => {
+			e();
+		}));
+	}
+	listenTo(e) {
+		this.addEffect(() => {
+			e(), this.update();
+		});
+	}
+	getShortCutKeys() {
+		let e = this.shortCutKey;
+		if (e === void 0) return;
+		let t = [];
+		return this.shortCutKeyOnCtrl && t.push(i() ? "Cmd" : "Ctrl"), this.shortCutKeyOnAlt && t.push("Alt"), this.shortCutKeyOnShift && t.push("Shift"), t.push(e), t;
+	}
+	hasShortCutKey(e, t, n, r) {
+		return this.shortCutKey === e && this.shortCutKeyOnCtrl === t && this.shortCutKeyOnShift === n && this.shortCutKeyOnAlt === r;
+	}
+};
+//#endregion
+export { s as BaseCommand };

package/dist/foundation/commands/BaseEditTool.d.ts

@@ -0,0 +1,68 @@
+import { AnyIntersection } from '@cognite/reveal';
+import { NavigationTool } from '../concreteCommands/navigation/NavigationTool';
+import { DomainObject } from '../domainObjects/DomainObject';
+import { VisualDomainObject } from '../domainObjects/VisualDomainObject';
+import { BaseDragger } from '../domainObjectsHelpers/BaseDragger';
+import { Class } from '../domainObjectsHelpers/Class';
+import { CommandsController } from '../renderTarget/CommandsController';
+/**
+ * The `BaseEditTool` class is an abstract class that extends the `NavigationTool` class.
+ * It provides a base implementation for editing tools in a specific architecture.
+ * Custom editing tools can be created by extending this class and overriding its methods.
+ * This class will also provide the dragging functionality if the picked domain object has
+ * createDragger() overridden.
+ */
+export declare abstract class BaseEditTool extends NavigationTool {
+    private _dragger;
+    get defaultCursor(): string;
+    clearDragging(): void;
+    onLeftPointerDown(event: PointerEvent): Promise<void>;
+    onLeftPointerDrag(event: PointerEvent): Promise<void>;
+    onLeftPointerUp(event: PointerEvent): Promise<void>;
+    onActivate(): void;
+    onDeactivate(): void;
+    /**
+     * Determines whether the specified domain object can be selected or dragged by this edit tool.
+     * Override this function of the selection mechanism should be used.
+     * @param domainObject - The domain object to be accepted.
+     * @returns `true` if the domain object can be accepted, `false` otherwise.
+     */
+    protected canBeSelected(_domainObject: VisualDomainObject): boolean;
+    /**
+     * Override this function to create custom dragger
+     * with other creation logic.
+     */
+    protected createDragger(event: PointerEvent): Promise<BaseDragger | undefined>;
+    /**
+     * Deselects all selectable objects except for the specified object.
+     * If no object is specified, all visual domain objects will be deselected.
+     * @param except - The visual domain object to exclude from deselection.
+     */
+    protected deselectAll(except?: VisualDomainObject | undefined): void;
+    protected getSelectable(): Generator<VisualDomainObject>;
+    protected getSelectableByType<T extends DomainObject>(classType: Class<T>): Generator<T>;
+    /**
+     * Retrieves the selected VisualDomainObject.
+     * Use only if single selection is expected.
+     * @returns The selected DomainObject, or undefined if no object is selected.
+     */
+    protected getSelected(): VisualDomainObject | undefined;
+    /**
+     * Retrieves all selected domain objects.
+     * Use only if multi selection is expected.
+     * @returns A generator that yields each selected domain object.
+     */
+    protected getAllSelected(): Generator<VisualDomainObject>;
+    /**
+     * Sets the visibility of all selectable objects.
+     * @param visible - A boolean indicating whether the objects should be visible or not.
+     */
+    protected setAllVisible(visible: boolean): void;
+    /**
+     * Retrieves the intersected visual domain object from the given intersection.
+     * @param intersection - The intersection to retrieve the domain object from.
+     * @returns The intersected visual domain object, or undefined if no valid domain object is found.
+     */
+    protected getIntersectedSelectableDomainObject(intersection: AnyIntersection | undefined): VisualDomainObject | undefined;
+}
+export declare function isActiveEditTool(commandController: CommandsController): boolean;

package/dist/foundation/commands/BaseEditTool.js

@@ -0,0 +1,85 @@
+import { isInstanceOf as e } from "../domainObjectsHelpers/Class.js";
+import { VisualDomainObject as t } from "../domainObjects/VisualDomainObject.js";
+import { VIEWER_TO_CDF_TRANSFORMATION as n, convertFromViewerCoordinates as r } from "../renderTarget/convertCoordinates.js";
+import { isDomainObjectIntersection as i } from "../domainObjectsHelpers/DomainObjectIntersection.js";
+import { NavigationTool as a } from "../concreteCommands/navigation/NavigationTool.js";
+//#region libs/shared/reveal-components/src/foundation/commands/BaseEditTool.ts
+var o = class extends a {
+	_dragger = void 0;
+	get defaultCursor() {
+		return "crosshair";
+	}
+	clearDragging() {
+		super.clearDragging(), this._dragger = void 0;
+	}
+	async onLeftPointerDown(e) {
+		if (this._dragger = await this.createDragger(e), this._dragger === void 0) {
+			await super.onLeftPointerDown(e);
+			return;
+		}
+		this._dragger.onPointerDown(e), this.deselectAll(this._dragger.domainObject), this._dragger.domainObject.setSelected(!0);
+	}
+	async onLeftPointerDrag(e) {
+		if (this._dragger === void 0) {
+			await super.onLeftPointerDrag(e);
+			return;
+		}
+		let t = this.getRay(e, !0);
+		this._dragger.onPointerDrag(e, t) && (this._dragger.isChanged = !0);
+	}
+	async onLeftPointerUp(e) {
+		this._dragger === void 0 ? await super.onLeftPointerUp(e) : (this._dragger.onPointerUp(e), this._dragger.isChanged && this.addTransaction(this._dragger.transaction), this._dragger = void 0);
+	}
+	onActivate() {
+		super.onActivate();
+		let e = this.getSelected();
+		this.renderTarget.panelUpdater.show(e);
+	}
+	onDeactivate() {
+		super.onDeactivate(), this.renderTarget.panelUpdater.hide();
+	}
+	canBeSelected(e) {
+		return !1;
+	}
+	async createDragger(e) {
+		let t = await this.getIntersection(e);
+		if (t === void 0 || !i(t)) return;
+		let a = this.getIntersectedSelectableDomainObject(t);
+		if (a === void 0) return;
+		let o = r(t.point), s = this.getRay(e);
+		return s.applyMatrix4(n), a.createDragger({
+			intersection: t,
+			point: o,
+			ray: s
+		});
+	}
+	deselectAll(e) {
+		for (let t of this.getSelectable()) (e === void 0 || t !== e) && t.setSelected(!1);
+	}
+	*getSelectable() {
+		let { root: e } = this;
+		for (let n of e.getDescendantsByType(t)) this.canBeSelected(n) && (yield n);
+	}
+	*getSelectableByType(t) {
+		for (let n of this.getSelectable()) e(n, t) && (yield n);
+	}
+	getSelected() {
+		for (let e of this.getSelectable()) if (e.isSelected) return e;
+	}
+	*getAllSelected() {
+		for (let e of this.getSelectable()) e.isSelected && (yield e);
+	}
+	setAllVisible(e) {
+		for (let t of this.getSelectable()) t.setVisible(e, this.renderTarget);
+	}
+	getIntersectedSelectableDomainObject(e) {
+		if (!i(e)) return;
+		let { domainObject: n } = e;
+		if (n instanceof t && this.canBeSelected(n)) return n;
+	}
+};
+function s(e) {
+	return e.activeTool instanceof o;
+}
+//#endregion
+export { o as BaseEditTool, s as isActiveEditTool };