@cognite/reveal-components 1.0.0

package/dist/foundation/treeNodes/tree-node/tree-node-functions.d.ts

@@ -0,0 +1,17 @@
+import { TreeNode } from './tree-node';
+export declare function onSelectNode(node: TreeNode, isShift: boolean, isControl: boolean, lastSelectedNode?: TreeNode): boolean;
+/**
+ * Handles the event when a node's checkbox is clicked, toggling its state between `All` and `None`.
+ * It also updates the checkbox states of all its descendants and ancestors.
+ *
+ * @param node - The tree node that was clicked.
+ *
+ * @remarks
+ * - If the node's checkbox state is `All`, it will be set to `None`, and vice versa.
+ * - All descendants of the node will have their checkbox states updated to match the node's
+ *   new state, unless their state is undefined.
+ * - All ancestors of the node will have their checkbox states recalculated,
+ *   unless their state is undefined.
+ */
+export declare function onToggleNode(node: TreeNode): boolean;
+export declare function clearSelection(root: TreeNode, except?: TreeNode): boolean;

package/dist/foundation/treeNodes/tree-node/tree-node-functions.js

@@ -0,0 +1,44 @@
+import { CheckboxState as e } from "../../utilities/types.js";
+import { TreeNode as t } from "./tree-node.js";
+//#region libs/shared/reveal-components/src/foundation/treeNodes/tree-node/tree-node-functions.ts
+function n(e, t, n, r) {
+	let i = e.getRoot();
+	if (i === void 0) return !1;
+	if (n) return e.isSelected = !e.isSelected, !0;
+	if (t && r !== void 0 && r.isSelected) {
+		let t = Array.from(i.getExpandedThisAndDescendants()), n = t.indexOf(r);
+		if (n >= 0) {
+			let r = t.indexOf(e);
+			if (r >= 0) {
+				r < n && ([n, r] = [r, n]);
+				let e = !1;
+				for (let i = 0; i < t.length; i++) t[i].setSelected(n <= i && i <= r) && (e = !0);
+				return e;
+			}
+		}
+	}
+	let o = a(i, e);
+	return e.setSelected(!0) || o;
+}
+function r(n) {
+	if (n.checkboxState === void 0) return !1;
+	n.checkboxState = n.checkboxState === e.All ? e.None : e.All;
+	for (let e of n.getDescendants()) e.checkboxState !== void 0 && (e.checkboxState = n.checkboxState);
+	for (let e of n.getAncestorsByType(t)) e.checkboxState !== void 0 && (e.checkboxState = i(e));
+	return !0;
+}
+function i(t) {
+	let n = 0, r = 0, i = 0;
+	for (let a of t.getChildren()) {
+		let t = a.checkboxState;
+		if (a.isCheckboxEnabled === !0 && t !== void 0 && (n++, t === e.All ? r++ : t === e.None && i++, r > 0 && i > 0)) return e.Some;
+	}
+	return n === 0 ? t.checkboxState : n === r ? e.All : n === i ? e.None : e.Some;
+}
+function a(e, n) {
+	let r = !1;
+	for (let i of e.getThisAndDescendantsByType(t)) i !== n && i.setSelected(!1) && (r = !0);
+	return r;
+}
+//#endregion
+export { a as clearSelection, n as onSelectNode, r as onToggleNode };

package/dist/foundation/treeNodes/tree-node/tree-node.d.ts

@@ -0,0 +1,94 @@
+import { Signal } from '@cognite/signal-utils';
+import { Class } from '../../domainObjectsHelpers/Class';
+import { IconColor, IconName, CheckboxState, UniqueId } from '../../utilities/types';
+import { ILazyLoader } from '../tree-node-type/i-lazy-loader';
+import { TreeNodeType } from '../tree-node-type/tree-node-type';
+/**
+ * Represents a node in a tree structure.
+ * This is the default Implements the TreeNodeType interface and can be reused
+ * By default it is a simple tree node with a label.
+ * in most cases.
+ */
+export declare class TreeNode implements TreeNodeType {
+    readonly updateSignal: Signal<number>;
+    private _id?;
+    private _label;
+    private _icon;
+    private _iconColor;
+    private _isSelected;
+    private _checkboxState;
+    private _tooltip;
+    private _isExpanded;
+    private _isCheckboxEnabled;
+    private _hasBoldLabel;
+    private _hasInfoIcon;
+    private _isLoadingChildren;
+    private _isLoadingSiblings;
+    private _needLoadChildren;
+    private _needLoadSiblings;
+    protected _children: TreeNode[] | undefined;
+    protected _parent: TreeNode | undefined;
+    get childCount(): number;
+    get id(): UniqueId;
+    get label(): string;
+    set label(value: string);
+    get hasBoldLabel(): boolean;
+    set hasBoldLabel(value: boolean);
+    get icon(): IconName;
+    set icon(value: IconName);
+    get iconColor(): IconColor;
+    set iconColor(value: IconColor);
+    get hasInfoIcon(): boolean;
+    set hasInfoIcon(value: boolean);
+    get isSelected(): boolean;
+    set isSelected(value: boolean);
+    get isExpanded(): boolean;
+    set isExpanded(value: boolean);
+    get isCheckboxEnabled(): boolean;
+    set isCheckboxEnabled(value: boolean);
+    get checkboxState(): CheckboxState | undefined;
+    set checkboxState(value: CheckboxState | undefined);
+    get tooltip(): string | undefined;
+    set tooltip(value: string | undefined);
+    get needLoadChildren(): boolean;
+    set needLoadChildren(value: boolean);
+    get needLoadSiblings(): boolean;
+    set needLoadSiblings(value: boolean);
+    get isLoadingChildren(): boolean;
+    set isLoadingChildren(value: boolean);
+    get isLoadingSiblings(): boolean;
+    set isLoadingSiblings(value: boolean);
+    get isParent(): boolean;
+    get parent(): TreeNode | undefined;
+    get children(): TreeNode[] | undefined;
+    areEqual(child: TreeNode): boolean;
+    getRoot(): TreeNode;
+    getLastChild(): TreeNode | undefined;
+    getSelectedNodes(): TreeNode[];
+    getCheckedNodes(): TreeNode[];
+    deselectAll(): void;
+    expandAllAncestors(): void;
+    getChildren(loader?: ILazyLoader): Generator<TreeNode>;
+    getChildrenByType<Type extends TreeNodeType>(classType: Class<Type>): Generator<Type>;
+    getDescendants(): Generator<TreeNode>;
+    getExpandedThisAndDescendants(): Generator<TreeNode>;
+    getDescendantsByType<Type extends TreeNodeType>(classType: Class<Type>): Generator<Type>;
+    getThisAndDescendants(): Generator<TreeNode>;
+    getThisAndDescendantsByType<Type extends TreeNodeType>(classType: Class<Type>): Generator<Type>;
+    getAncestors(): Generator<TreeNode>;
+    getAncestorsByType<Type extends TreeNodeType>(classType: Class<Type>): Generator<Type>;
+    getThisAndAncestorsByType<Type extends TreeNodeType>(classType: Class<Type>): Generator<Type>;
+    addChild(child: TreeNode): void;
+    insertChild(index: number, child: TreeNode): void;
+    loadChildren(loader: ILazyLoader): Promise<void>;
+    loadSiblings(loader: ILazyLoader): Promise<void>;
+    hasChild(child: TreeNode): boolean;
+    /**
+     * Sets the selection state
+     *
+     * @param isSelected - Whether the node should be selected. Defaults to true
+     * @returns True if the selection state was changed, false if it was already in the desired state
+     */
+    setSelected(isSelected?: boolean): boolean;
+    update(): void;
+}

package/dist/foundation/treeNodes/tree-node/tree-node.js

@@ -0,0 +1,238 @@
+import { isInstanceOf as e } from "../../domainObjectsHelpers/Class.js";
+import { insertAt as t } from "../../utilities/extensions/arrayUtils.js";
+import { CheckboxState as n, generateUniqueId as r } from "../../utilities/types.js";
+import { incrementSignal as i } from "../../utilities/misc/incrementSignal.js";
+import { signal as a } from "@cognite/signal-utils";
+//#region libs/shared/reveal-components/src/foundation/treeNodes/tree-node/tree-node.ts
+var o = class o {
+	updateSignal = a(0);
+	_id;
+	_label = "";
+	_icon = void 0;
+	_iconColor = void 0;
+	_isSelected = !1;
+	_checkboxState = void 0;
+	_tooltip = void 0;
+	_isExpanded = !1;
+	_isCheckboxEnabled = !0;
+	_hasBoldLabel = !1;
+	_hasInfoIcon = !1;
+	_isLoadingChildren = !1;
+	_isLoadingSiblings = !1;
+	_needLoadChildren = !1;
+	_needLoadSiblings = !1;
+	_children = void 0;
+	_parent = void 0;
+	get childCount() {
+		return this.children?.length ?? 0;
+	}
+	get id() {
+		return this._id === void 0 && (this._id = r()), this._id;
+	}
+	get label() {
+		return this._label;
+	}
+	set label(e) {
+		this._label !== e && (this._label = e, this.update());
+	}
+	get hasBoldLabel() {
+		return this._hasBoldLabel;
+	}
+	set hasBoldLabel(e) {
+		this._hasBoldLabel !== e && (this._hasBoldLabel = e, this.update());
+	}
+	get icon() {
+		return this._icon;
+	}
+	set icon(e) {
+		this._icon !== e && (this._icon = e, this.update());
+	}
+	get iconColor() {
+		return this._iconColor;
+	}
+	set iconColor(e) {
+		this._iconColor !== e && (this._iconColor = e, this.update());
+	}
+	get hasInfoIcon() {
+		return this._hasInfoIcon;
+	}
+	set hasInfoIcon(e) {
+		this._hasInfoIcon !== e && (this._hasInfoIcon = e, this.update());
+	}
+	get isSelected() {
+		return this._isSelected;
+	}
+	set isSelected(e) {
+		this._isSelected !== e && (this._isSelected = e, this.update());
+	}
+	get isExpanded() {
+		return this._isExpanded;
+	}
+	set isExpanded(e) {
+		this._isExpanded !== e && (this._isExpanded = e, this.update());
+	}
+	get isCheckboxEnabled() {
+		return this._isCheckboxEnabled;
+	}
+	set isCheckboxEnabled(e) {
+		this._isCheckboxEnabled !== e && (this._isCheckboxEnabled = e, this.update());
+	}
+	get checkboxState() {
+		return this._checkboxState;
+	}
+	set checkboxState(e) {
+		this._checkboxState !== e && (this._checkboxState = e, this.update());
+	}
+	get tooltip() {
+		return this._tooltip;
+	}
+	set tooltip(e) {
+		this._tooltip !== e && (this._tooltip = e, this.update());
+	}
+	get needLoadChildren() {
+		return this._needLoadChildren;
+	}
+	set needLoadChildren(e) {
+		this._needLoadChildren !== e && (this._needLoadChildren = e, this.update());
+	}
+	get needLoadSiblings() {
+		return this._needLoadSiblings;
+	}
+	set needLoadSiblings(e) {
+		this._needLoadSiblings !== e && (this._needLoadSiblings = e, this.update());
+	}
+	get isLoadingChildren() {
+		return this._isLoadingChildren;
+	}
+	set isLoadingChildren(e) {
+		this._isLoadingChildren !== e && (this._isLoadingChildren = e, this.update());
+	}
+	get isLoadingSiblings() {
+		return this._isLoadingSiblings;
+	}
+	set isLoadingSiblings(e) {
+		this._isLoadingSiblings !== e && (this._isLoadingSiblings = e, this.update());
+	}
+	get isParent() {
+		return this.needLoadChildren ? !0 : this._children !== void 0 && this._children.length > 0;
+	}
+	get parent() {
+		return this._parent;
+	}
+	get children() {
+		return this._children;
+	}
+	areEqual(e) {
+		return this === e;
+	}
+	getRoot() {
+		return this.parent === void 0 ? this : this.parent.getRoot();
+	}
+	getLastChild() {
+		if (this._children !== void 0) return this._children[this._children.length - 1];
+	}
+	getSelectedNodes() {
+		let e = [];
+		for (let t of this.getThisAndDescendants()) t.isSelected && e.push(t);
+		return e;
+	}
+	getCheckedNodes() {
+		let e = [];
+		for (let t of this.getThisAndDescendants()) t.checkboxState === n.All && e.push(t);
+		return e;
+	}
+	deselectAll() {
+		for (let e of this.getThisAndDescendants()) e.isSelected = !1;
+	}
+	expandAllAncestors() {
+		for (let e of this.getAncestors()) e.isExpanded = !0;
+	}
+	*getChildren(e) {
+		if (this.isLoadingChildren && (e = void 0), this.isParent && e !== void 0 && this.needLoadChildren && this.loadChildren(e), this._children !== void 0) for (let e of this._children) yield e;
+	}
+	*getChildrenByType(t) {
+		for (let n of this.getChildren()) e(n, t) && (yield n);
+	}
+	*getDescendants() {
+		for (let e of this.getChildren()) yield e, yield* e.getDescendants();
+	}
+	*getExpandedThisAndDescendants() {
+		if (yield this, this.isExpanded) for (let e of this.getChildrenByType(o)) yield* e.getExpandedThisAndDescendants();
+	}
+	*getDescendantsByType(t) {
+		for (let n of this.getDescendants()) e(n, t) && (yield n);
+	}
+	*getThisAndDescendants() {
+		yield this;
+		for (let e of this.getDescendants()) yield e;
+	}
+	*getThisAndDescendantsByType(t) {
+		for (let n of this.getThisAndDescendants()) e(n, t) && (yield n);
+	}
+	*getAncestors() {
+		let e = this.parent;
+		for (; e !== void 0;) yield e, e = e.parent;
+	}
+	*getAncestorsByType(t) {
+		let n = this.parent;
+		for (; n !== void 0 && e(n, t);) yield n, n = n.parent;
+	}
+	*getThisAndAncestorsByType(t) {
+		if (e(this, t)) {
+			yield this;
+			for (let e of this.getAncestorsByType(t)) yield e;
+		}
+	}
+	addChild(e) {
+		this._children === void 0 && (this._children = []), this._children.push(e), e._parent = this, this.update();
+	}
+	insertChild(e, n) {
+		this._children === void 0 && (this._children = []), t(this._children, e, n), n._parent = this, this.update();
+	}
+	async loadChildren(e) {
+		this.isLoadingChildren = !0;
+		let t = await e.loadChildren(this);
+		if (this.isLoadingChildren = !1, t !== void 0 && t.length !== 0) {
+			if (this._children === void 0 && (this._children = []), t !== void 0) {
+				for (let n of t) if (n instanceof o) {
+					this.addChild(n);
+					try {
+						e.onNodeLoaded?.(n, this);
+					} catch (e) {
+						throw console.error("Error in onNodeLoaded in loadChildren", e), e;
+					}
+				}
+			}
+			this.needLoadChildren = !1;
+		}
+	}
+	async loadSiblings(e) {
+		let t = this.parent;
+		if (t === void 0 || t._children === void 0) return;
+		this.isLoadingSiblings = !0;
+		let n = await e.loadSiblings(this);
+		if (this.isLoadingSiblings = !1, n === void 0 || n.length === 0) return;
+		let r = t._children.indexOf(this);
+		if (r === void 0 || r < 0) throw Error("Illegal parent-child relationship");
+		for (let i of n) if (i instanceof o && !t.hasChild(i)) {
+			r++, t.insertChild(r, i);
+			try {
+				e.onNodeLoaded?.(i, t);
+			} catch (e) {
+				throw console.error("Error in onNodeLoaded in loadSiblings", e), e;
+			}
+		}
+		this.needLoadSiblings = !1;
+	}
+	hasChild(e) {
+		return this._children !== void 0 && this._children.some((t) => t.areEqual(e));
+	}
+	setSelected(e = !0) {
+		return this.isSelected !== e && (this.isSelected = e, !0);
+	}
+	update() {
+		i(this.updateSignal);
+	}
+};
+//#endregion
+export { o as TreeNode };

package/dist/foundation/treeNodes/tree-node-type/i-lazy-loader.d.ts

@@ -0,0 +1,58 @@
+import { OnNodeLoadedAction } from './tree-node-actions';
+import { TreeNodeType } from './tree-node-type';
+/** Interface for lazy loading tree nodes
+ *
+ * */
+export type ILazyLoader = {
+    /**
+     * Gets the root node of the tree. If loadInitialRoot is not called, the root node is undefined.
+     *
+     * @returns {TreeNodeType | undefined} The root node of the tree, or undefined if the root node is not set.
+     */
+    root: TreeNodeType | undefined;
+    /**
+     * Loads the initial root node of the tree.
+     *
+     * @returns {Promise<TreeNodeType>} A promise that resolves to the root node of the tree.
+     *
+     * @remarks
+     * If the root node has already been loaded, it returns the cached root node.
+     * Otherwise, it should fetch the root node ,
+     * sets it as the root node, marks it as expanded, and caches it for future use.
+     *
+     * @throws {Error} If there is an issue with fetching the root node from the SDK.
+     */
+    loadInitialRoot?: () => Promise<TreeNodeType>;
+    /**
+     * Load children for for a given parent node
+     * @param node - The parent node for which to load children
+     * @returns A promise that resolves to an array of tree nodes or undefined.
+     */
+    loadChildren: (parent: TreeNodeType) => Promise<TreeNodeType[] | undefined>;
+    /**
+     * Load siblings for a given node (the sibling will be inserted just after the node)
+     * @param sibling - The sibling to where th other siblings are loaded from
+     * @returns A promise that resolves to an array of tree nodes or undefined.
+     */
+    loadSiblings: (sibling: TreeNodeType) => Promise<TreeNodeType[] | undefined>;
+    /**
+     * Forces a node to be present in the tree by an nodeIdentifier. If the node is already in the tree,
+     * it expands all its ancestors and returns the node. If the node is not in the tree, it fetches
+     * the ancestors of the node, inserts them into the tree, expands all ancestors of the new node,
+     * and returns the new node.
+     *
+     * @param nodeIdentifier - The identifier of the node to be forced into the tree. What the nodeIdentifier
+     * will be is up to the implementation of the lazy loader, since this method is not called by the tree view.
+     * @returns A promise that resolves to the tree node if it is successfully forced into the tree,
+     *          or undefined if the root is undefined or the node could not be inserted.
+     */
+    forceNodeInTree?: (nodeIdentifier: number) => Promise<TreeNodeType | undefined>;
+    /**
+     * Callback function that is triggered when a node is loaded and just after it is
+     * added/inserted into the tree.
+     *
+     * @param child - The child node that has been loaded.
+     * @param parent - (Optional) The parent node of the loaded child node.
+     */
+    onNodeLoaded?: OnNodeLoadedAction;
+};

package/dist/foundation/treeNodes/tree-node-type/tree-node-actions.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../commands/BaseCommand';
+import { TreeNodeType } from './tree-node-type';
+export type TreeNodeAction = (node: TreeNodeType) => void;
+export type TreeNodeSelectAction = (node: TreeNodeType, isShiftPressed: boolean, isControlPressed: boolean) => void;
+/**
+ * This defines a type alias LoadNodesAction for a function. This type is likely used to represent asynchronous actions for loading nodes in
+ * the tree view.
+ * @param node - The parent or the sibling node to load siblings for.
+ * @param boolean - True of children should be loaded, false if the sibling
+ * @return A Promise that resolves to an array of TreeNodeType objects or undefined.
+ * @beta
+ */
+export type OnNodeLoadedAction = (child: TreeNodeType, parent?: TreeNodeType) => void;
+export type GetTreeNodeContextMenu = (node: TreeNodeType) => BaseCommand[] | undefined;

package/dist/foundation/treeNodes/tree-node-type/tree-node-type.d.ts

@@ -0,0 +1,41 @@
+import { Signal } from '@cognite/signal-utils';
+import { IconColor, IconName, CheckboxState, UniqueId } from '../../utilities/types';
+import { ILazyLoader } from './i-lazy-loader';
+export type TreeNodeType = {
+    updateSignal: Signal<number>;
+    id: UniqueId;
+    label: string;
+    isSelected: boolean;
+    isExpanded: boolean;
+    isVisibleInTree?: boolean;
+    isParent: boolean;
+    hasBoldLabel?: boolean;
+    hasInfoIcon?: boolean;
+    icon?: IconName;
+    iconColor?: IconColor;
+    isCheckboxEnabled?: boolean;
+    checkboxState?: CheckboxState;
+    tooltip?: string;
+    needLoadSiblings?: boolean;
+    isLoadingChildren?: boolean;
+    isLoadingSiblings?: boolean;
+    /**
+     * (Required) Get the children of this node. If the children are not loaded,
+     * the lazy loader loader will optionally be used to load the children.
+     */
+    getChildren: (loader?: ILazyLoader) => Generator<TreeNodeType>;
+    /**
+     * The siblings will be inserted just after the this node.
+     */
+    loadSiblings?: (loader: ILazyLoader) => Promise<void>;
+    /**
+     * Optional hook called when the node is clicked/selected in a tree view.
+     * If omitted, the tree view falls back to its default selection behavior for the node.
+     */
+    onSelect?: () => void;
+    /**
+     * Toggles the visibility of the node, e.g. when its checkbox is clicked in a tree view.
+     * DomainObject already implements this, so it satisfies this member without any change.
+     */
+    toggleVisible?: () => void;
+};

package/dist/foundation/undo/DomainObjectTransaction.d.ts

@@ -0,0 +1,13 @@
+import { DomainObject } from '../domainObjects/DomainObject';
+import { RenderTarget } from '../renderTarget/RenderTarget';
+import { Transaction } from './Transaction';
+/**
+ * Represents an generic transaction used for undo.
+ * It implements undo transaction for added, deleted, name, color, geometry
+ * and render style changes.
+ */
+export declare class DomainObjectTransaction extends Transaction {
+    private readonly copy?;
+    constructor(domainObject: DomainObject, changed: symbol);
+    protected undoCore(domainObject: DomainObject, renderTarget: RenderTarget): boolean;
+}

package/dist/foundation/undo/DomainObjectTransaction.js

@@ -0,0 +1,28 @@
+import { Changes as e } from "../domainObjectsHelpers/Changes.js";
+import { Transaction as t } from "./Transaction.js";
+//#region libs/shared/reveal-components/src/foundation/undo/DomainObjectTransaction.ts
+var n = class extends t {
+	copy;
+	constructor(t, n) {
+		super(t, n), n === e.deleted ? this.copy = t.clone() : n !== e.added && (this.copy = t.clone(n));
+	}
+	undoCore(t, n) {
+		switch (this.changed) {
+			case e.added:
+				t.remove();
+				break;
+			case e.deleted: {
+				if (this.copy === void 0) return !1;
+				let e = this.copy;
+				t.addChild(e), e.setVisible(!0, n);
+				break;
+			}
+			default:
+				if (this.copy === void 0) return !1;
+				t.copyFrom(this.copy, this.changed), t.notify(this.changed), t.setVisible(!0, n);
+		}
+		return !0;
+	}
+};
+//#endregion
+export { n as DomainObjectTransaction };

package/dist/foundation/undo/Transaction.d.ts

@@ -0,0 +1,12 @@
+import { DomainObject } from '../domainObjects/DomainObject';
+import { RenderTarget } from '../renderTarget/RenderTarget';
+import { UniqueId } from '../utilities/types';
+export declare abstract class Transaction {
+    readonly changed: symbol;
+    readonly uniqueId: UniqueId;
+    private readonly _parentUniqueId?;
+    readonly timeStamp: number;
+    protected constructor(domainObject: DomainObject, changed: symbol);
+    protected abstract undoCore(domainObject: DomainObject, renderTarget: RenderTarget): boolean;
+    undo(renderTarget: RenderTarget): boolean;
+}

package/dist/foundation/undo/Transaction.js

@@ -0,0 +1,21 @@
+import { Changes as e } from "../domainObjectsHelpers/Changes.js";
+//#region libs/shared/reveal-components/src/foundation/undo/Transaction.ts
+var t = class {
+	changed;
+	uniqueId;
+	_parentUniqueId;
+	timeStamp = Date.now();
+	constructor(e, t) {
+		this.uniqueId = e.uniqueId, this.changed = t;
+		let n = e.parent;
+		n !== void 0 && (this._parentUniqueId = n.uniqueId);
+	}
+	undo(t) {
+		let n = t.root, r = this.changed === e.deleted ? this._parentUniqueId : this.uniqueId;
+		if (r === void 0) return !1;
+		let i = n.getThisOrDescendantByUniqueId(r);
+		return i !== void 0 && (this.undoCore(i, t), !0);
+	}
+};
+//#endregion
+export { t as Transaction };

package/dist/foundation/undo/UndoManager.d.ts

@@ -0,0 +1,16 @@
+import { UniqueId } from '../../foundation/utilities/types';
+import { RenderTarget } from '../renderTarget/RenderTarget';
+import { Transaction } from './Transaction';
+export declare class UndoManager {
+    private readonly _transactions;
+    /**
+     * Adds a transaction to the undo manager.
+     *
+     * @param transaction - The transaction to be added. If undefined, the transaction will not be added.
+     * @returns A boolean indicating whether the ability to undo has changed as a result of adding the transaction.
+     */
+    addTransaction(transaction: Transaction | undefined): boolean;
+    undo(renderTarget: RenderTarget): boolean;
+    get canUndo(): boolean;
+    hasUniqueId(uniqueId: UniqueId): boolean;
+}

package/dist/foundation/undo/UndoManager.js

@@ -0,0 +1,28 @@
+//#region libs/shared/reveal-components/src/foundation/undo/UndoManager.ts
+var e = class {
+	_transactions = [];
+	addTransaction(e) {
+		if (e === void 0) return !1;
+		let t = this.canUndo;
+		return this._transactions.push(e), t !== this.canUndo;
+	}
+	undo(e) {
+		if (this._transactions.length === 0) return !1;
+		let t = this._transactions.pop();
+		if (t === void 0) throw Error("Transaction is undefined");
+		let n = t.undo(e), r = t.timeStamp;
+		for (let i = this._transactions.length - 1; i >= 0 && !(Math.abs(this._transactions[i].timeStamp - r) > 500); i--) {
+			if (t = this._transactions.pop(), t === void 0) throw Error("Transaction is undefined");
+			r = t.timeStamp, t.undo(e) && (n = !0);
+		}
+		return n;
+	}
+	get canUndo() {
+		return this._transactions.length > 0;
+	}
+	hasUniqueId(e) {
+		return this._transactions.find((t) => t.uniqueId === e) !== void 0;
+	}
+};
+//#endregion
+export { e as UndoManager };

package/dist/foundation/utilities/colors/ColorInterpolation.d.ts

@@ -0,0 +1,5 @@
+export declare enum ColorInterpolation {
+    Rgb = 0,
+    HslShort = 1,
+    HslLong = 2
+}

package/dist/foundation/utilities/colors/ColorInterpolation.js

@@ -0,0 +1,6 @@
+//#region libs/shared/reveal-components/src/foundation/utilities/colors/ColorInterpolation.ts
+var e = /* @__PURE__ */ function(e) {
+	return e[e.Rgb = 0] = "Rgb", e[e.HslShort = 1] = "HslShort", e[e.HslLong = 2] = "HslLong", e;
+}({});
+//#endregion
+export { e as ColorInterpolation };

package/dist/foundation/utilities/colors/ColorMap.d.ts

@@ -0,0 +1,17 @@
+import { Color } from 'three';
+import { Range1 } from '../geometry/Range1';
+import { ColorInterpolation } from './ColorInterpolation';
+import { ColorMapType } from './ColorMapType';
+export declare const BYTE_PR_COLOR = 4;
+export declare const TEXTURE_1D_WIDTH = 2;
+export declare class ColorMap {
+    private readonly _items;
+    private _maxIndex;
+    colorMapType: ColorMapType;
+    getColor(fraction: number): Color;
+    private getColorFast;
+    add(color: Color, fraction: number, interpolation: ColorInterpolation): void;
+    reverse(): void;
+    createColors(size?: number): Uint8Array;
+    createColorsWithContours(range: Range1, increment: number, volume: number, solidColor?: Color, size?: number): Uint8Array;
+}