@cognite/reveal-components 1.0.0

package/dist/foundation/concreteCommands/units/SetLengthUnitCommand.js

@@ -0,0 +1,36 @@
+import { RenderTargetCommand as e } from "../../commands/RenderTargetCommand.js";
+import { BaseOptionCommand as t } from "../../commands/BaseOptionCommand.js";
+import { LengthUnit as n, UnitSystem as r } from "../../renderTarget/UnitSystem.js";
+//#region libs/shared/reveal-components/src/foundation/concreteCommands/units/SetLengthUnitCommand.ts
+var i = class extends t {
+	constructor() {
+		super();
+		for (let e of [
+			n.Meter,
+			n.Feet,
+			n.Inch
+		]) this.add(new a(e));
+	}
+	get tooltip() {
+		return { key: "UNITS" };
+	}
+	attach(e) {
+		super.attach(e), this.listenTo(this.root.unitSystem.lengthUnit);
+	}
+}, a = class extends e {
+	_value;
+	constructor(e) {
+		super(), this._value = e;
+	}
+	get tooltip() {
+		return { untranslated: r.getFullTextForLengthUnit(this._value) };
+	}
+	get isChecked() {
+		return this.root.unitSystem.lengthUnit() === this._value;
+	}
+	invokeCore() {
+		return this.root.unitSystem.lengthUnit(this._value), !0;
+	}
+};
+//#endregion
+export { i as SetLengthUnitCommand };

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

@@ -0,0 +1,212 @@
+import { Color, Box3, ColorRepresentation } from 'three';
+import { Signal } from '@cognite/signal-utils';
+import { BaseCommand } from '../commands/BaseCommand';
+import { ChangedDescription } from '../domainObjectsHelpers/ChangedDescription';
+import { Class } from '../domainObjectsHelpers/Class';
+import { ColorType } from '../domainObjectsHelpers/ColorType';
+import { DomainObjectChange } from '../domainObjectsHelpers/DomainObjectChange';
+import { PanelInfo } from '../domainObjectsHelpers/PanelInfo';
+import { PopupStyle } from '../domainObjectsHelpers/PopupStyle';
+import { Views } from '../domainObjectsHelpers/Views';
+import { VisibleState } from '../domainObjectsHelpers/VisibleState';
+import { RenderStyle } from '../renderStyles/RenderStyle';
+import { RenderTarget } from '../renderTarget/RenderTarget';
+import { ILazyLoader } from '../treeNodes/tree-node-type/i-lazy-loader';
+import { TreeNodeType } from '../treeNodes/tree-node-type/tree-node-type';
+import { Transaction } from '../undo/Transaction';
+import { TranslationInput } from '../utilities/translation/TranslateInput';
+import { IconColor, IconName, CheckboxState, UniqueId } from '../utilities/types';
+/**
+ * Represents an abstract base class for domain objects.
+ * @abstract
+ */
+export declare abstract class DomainObject implements TreeNodeType {
+    private _name;
+    private _color;
+    private _tooltip;
+    private _isSelected;
+    private _isActive;
+    private _isExpanded;
+    private readonly _children;
+    private _parent;
+    private _renderStyle;
+    readonly views: Views;
+    private readonly _disposables;
+    get disposableCount(): number;
+    private _uniqueId;
+    get uniqueId(): UniqueId;
+    set uniqueId(value: UniqueId);
+    constructor();
+    readonly updateSignal: Signal<number>;
+    get id(): UniqueId;
+    get isVisibleInTree(): boolean;
+    get isParent(): boolean;
+    get iconColor(): IconColor;
+    get hasBoldLabel(): boolean;
+    get checkboxState(): CheckboxState | undefined;
+    get isCheckboxEnabled(): boolean;
+    get tooltip(): string | undefined;
+    set tooltip(value: string | undefined);
+    getChildren(_loader?: ILazyLoader): Generator<TreeNodeType>;
+    abstract get typeName(): TranslationInput;
+    get canChangeName(): boolean;
+    get name(): string | undefined;
+    set name(value: string | undefined);
+    get hasIndexOnLabel(): boolean;
+    get labelExtension(): string | undefined;
+    /**
+     * Generates a label for the domain object using the provided translation delegate.
+     * If the name is provided, the label is set to the name, else
+     * the label is constructed based on the object's type name, index, and label extension.
+     * The label is used in UI
+     * @remarks
+     * - If the object's name is already defined, the method returns early without modifying the label.
+     * - If the object has an index on the label, the index is appended to the label.
+     * - If the object has a label extension, it is appended to the label in parentheses.
+     */
+    get label(): string;
+    get canChangeColor(): boolean;
+    get hasIconColor(): boolean;
+    get color(): Color;
+    setColor(color: ColorRepresentation): void;
+    get canBeSelected(): boolean;
+    get isSelected(): boolean;
+    set isSelected(value: boolean);
+    setSelected(value: boolean): boolean;
+    get canBeActive(): boolean;
+    get isActive(): boolean;
+    set isActive(value: boolean);
+    setActive(): void;
+    get isExpanded(): boolean;
+    set isExpanded(value: boolean);
+    get canBeRemoved(): boolean;
+    canBeSetVisibleNow(_target: RenderTarget): boolean;
+    /**
+     * Gets a value indicating whether the domain object is legal.
+     * Normally it is legal, but if the object is pending when creating it, it is not legal.
+     * @returns {boolean} A boolean value indicating whether the domain object is legal.
+     */
+    get isLegal(): boolean;
+    /**
+     * Notifies the registered views and listeners about a change in the domain object.
+     * This method should be overridden in derived classes to provide custom implementation.
+     * @param change - The change object representing the update.
+     * @remarks
+     * Always call `super.notifyCore()` in the overrides.
+     */
+    protected notifyCore(change: DomainObjectChange): void;
+    /**
+     * Creates a transaction based on the specified changes. This is used for undoing
+     * @param changed - A symbol representing the changes made to the domain object.
+     * @returns A Transaction object if the transaction was created successfully, otherwise undefined.
+     */
+    createTransaction(_changed: symbol): Transaction | undefined;
+    /**
+     * Creates a copy of this the domain object. The copy will not include any parent/child relationships, or views
+     * @param what - Optional parameter specifying which properties to copy. If not provided, all properties will be copied.
+     * @returns A new domain object
+     */
+    clone(_what?: symbol): DomainObject;
+    /**
+     * Copies the properties from another `DomainObject` instance to this instance.
+     * @param domainObject - The `DomainObject` instance to copy from.
+     * @param what - Optional parameter specifying which properties to copy. If not provided, all properties will be copied.
+     */
+    copyFrom(domainObject: DomainObject, what?: symbol): void;
+    get hasPanelInfo(): boolean;
+    getPanelInfo(): PanelInfo | undefined;
+    getPanelInfoStyle(): PopupStyle;
+    getPanelToolbar(): BaseCommand[];
+    getContextMenu(): BaseCommand[] | undefined;
+    get icon(): IconName;
+    getBoundingBox(): Box3;
+    /**
+     * Expands the provided bounding box to include the bounds of this domain object.
+     * Override this to provide the actual implementation for specific domain object types.
+     *
+     * @param _boundingBox - The bounding box to be expanded. This parameter is typically modified in-place.
+     */
+    expandBoundingBox(_boundingBox: Box3): void;
+    /**
+     * Removes the core functionality of the domain object.
+     * This will automatically be called when the domain object is removed from its parent, by the function DomainObject.remove()
+     * This method should be overridden in derived classes to provide custom implementation.
+     * @remarks
+     * Always call `super.dispose()` in the overrides.
+     */
+    dispose(): void;
+    /**
+     * Override if the render style is taken from another domain object, for instance the parent
+     * or somewhere else in the hierarchy
+     * @returns The render style root
+     */
+    get renderStyleRoot(): DomainObject | undefined;
+    /**
+     * Override if this domain object is a render style root, se method above
+     * @returns true if this is a render style root
+     */
+    get isRenderStyleRoot(): boolean;
+    /**
+     * Factory method to create the render style for the domain object.
+     * Override this method to create a custom render style.
+     * @returns The render style
+     */
+    createRenderStyle(): RenderStyle | undefined;
+    /**
+     * Verifies the render style for the domain object, because the render style may
+     * be not valid in some cases. In this method you can change the render style.
+     * You can also change som fields in the renderStyle to get default values
+     * dependent of the domain object itself.
+     * Override this method when needed
+     */
+    verifyRenderStyle(_style: RenderStyle): void;
+    getVisibleState(renderTarget?: RenderTarget): VisibleState;
+    setVisible(visible: boolean, renderTarget?: RenderTarget | undefined, doNotify?: boolean): boolean;
+    notify(change: DomainObjectChange | ChangedDescription | symbol): void;
+    notifyDescendants(change: DomainObjectChange | ChangedDescription | symbol): void;
+    protected notifyVisibleStateChange(): void;
+    toggleVisible(renderTarget?: RenderTarget): void;
+    /**
+     * Checks if the domain object is visible in the specified render target.
+     * @param renderTarget - The render target to check visibility in.
+     * @returns `true` if the domain object is visible in the target, `false` otherwise.
+     */
+    isVisible(renderTarget?: RenderTarget): boolean;
+    get children(): DomainObject[];
+    get childCount(): number;
+    get childIndex(): number | undefined;
+    get parent(): DomainObject | undefined;
+    get root(): DomainObject;
+    get isRoot(): boolean;
+    get hasParent(): boolean;
+    hasChildByType<T extends DomainObject>(classType: Class<T>): boolean;
+    getChild(index: number): DomainObject;
+    getChildByType<T extends DomainObject>(classType: Class<T>): T | undefined;
+    getActiveChildByType<T extends DomainObject>(classType: Class<T>): T | undefined;
+    getChildrenByType<T extends DomainObject>(classType: Class<T>): Generator<T>;
+    getDescendants(): Generator<DomainObject>;
+    getThisAndDescendants(): Generator<DomainObject>;
+    getDescendantsByType<T extends DomainObject>(classType: Class<T>): Generator<T>;
+    getThisAndDescendantsByType<T extends DomainObject>(classType: Class<T>): Generator<T>;
+    getDescendantByType<T extends DomainObject>(classType: Class<T>): T | undefined;
+    hasDescendantByType<T extends DomainObject>(classType: Class<T>): boolean;
+    getThisOrDescendantByUniqueId(uniqueId: UniqueId): DomainObject | undefined;
+    getSelectedDescendant(): DomainObject | undefined;
+    getSelectedDescendantByType<T extends DomainObject>(classType: Class<T>): T | undefined;
+    getActiveDescendantByType<T extends DomainObject>(classType: Class<T>): T | undefined;
+    getAncestors(): Generator<DomainObject>;
+    getThisAndAncestors(): Generator<DomainObject>;
+    getAncestorByType<T>(classType: Class<T>): T | undefined;
+    getThisOrAncestorByType<T>(classType: Class<T>): T | undefined;
+    addChildRaw(child: DomainObject, index?: number): void;
+    addChild(child: DomainObject, index?: number): void;
+    private removeRaw;
+    remove(checkCanBeDeleted?: boolean): boolean;
+    getRenderStyle(): RenderStyle | undefined;
+    setRenderStyle(value?: RenderStyle | undefined): void;
+    private getTypeName;
+    supportsColorType(colorType: ColorType, solid: boolean): boolean;
+    getColorByColorType(colorType: ColorType): Color;
+    protected addDisposable(disposable: () => void): void;
+    protected addEffect(effectFunction: () => void): void;
+}

package/dist/foundation/domainObjects/DomainObject.js

@@ -0,0 +1,404 @@
+import { isTranslatedString as e } from "../utilities/translation/TranslateInput.js";
+import { translate as t } from "../utilities/translation/translateUtils.js";
+import { isInstanceOf as n } from "../domainObjectsHelpers/Class.js";
+import { clear as r, insertAt as i, removeAt as a } from "../utilities/extensions/arrayUtils.js";
+import { CheckboxState as o, generateUniqueId as s } from "../utilities/types.js";
+import { getRenderTarget as c } from "./getRoot.js";
+import { Changes as l } from "../domainObjectsHelpers/Changes.js";
+import { VisibleState as u } from "../domainObjectsHelpers/VisibleState.js";
+import { CopyToClipboardCommand as d } from "../concreteCommands/general/CopyToClipboardCommand.js";
+import { DeleteDomainObjectCommand as f } from "../concreteCommands/general/DeleteDomainObjectCommand.js";
+import { CycleLengthUnitsCommand as p } from "../concreteCommands/units/CycleLengthUnitsCommand.js";
+import { ChangedDescription as m } from "../domainObjectsHelpers/ChangedDescription.js";
+import { ColorType as h } from "../domainObjectsHelpers/ColorType.js";
+import { DomainObjectChange as g } from "../domainObjectsHelpers/DomainObjectChange.js";
+import { PopupStyle as _ } from "../domainObjectsHelpers/PopupStyle.js";
+import { Views as v } from "../domainObjectsHelpers/Views.js";
+import { BLACK_COLOR as y, WHITE_COLOR as b } from "../utilities/colors/colorUtils.js";
+import { getNextColor as x } from "../utilities/colors/getNextColor.js";
+import { incrementSignal as S } from "../utilities/misc/incrementSignal.js";
+import { effect as C, signal as w } from "@cognite/signal-utils";
+import { Box3 as T, Color as E } from "three";
+//#region libs/shared/reveal-components/src/foundation/domainObjects/DomainObject.ts
+var D = class {
+	_name = void 0;
+	_color;
+	_tooltip = void 0;
+	_isSelected = !1;
+	_isActive = !1;
+	_isExpanded = !1;
+	_children = [];
+	_parent = void 0;
+	_renderStyle = void 0;
+	views = new v();
+	_disposables = [];
+	get disposableCount() {
+		return this._disposables.length;
+	}
+	_uniqueId;
+	get uniqueId() {
+		return this._uniqueId;
+	}
+	set uniqueId(e) {
+		this._uniqueId = e;
+	}
+	constructor() {
+		this._uniqueId = s();
+	}
+	updateSignal = w(0);
+	get id() {
+		return this.uniqueId;
+	}
+	get isVisibleInTree() {
+		return !0;
+	}
+	get isParent() {
+		return this.childCount > 0;
+	}
+	get iconColor() {
+		if (this.hasIconColor) return this.color.getHexString();
+	}
+	get hasBoldLabel() {
+		return !1;
+	}
+	get checkboxState() {
+		switch (this.getVisibleState()) {
+			case u.All: return o.All;
+			case u.None: return o.None;
+			case u.Some: return o.Some;
+			default: return;
+		}
+	}
+	get isCheckboxEnabled() {
+		return this.getVisibleState() !== u.Disabled;
+	}
+	get tooltip() {
+		return this._tooltip;
+	}
+	set tooltip(e) {
+		this._tooltip = e;
+	}
+	*getChildren(e) {
+		for (let e of this.children) yield e;
+	}
+	get canChangeName() {
+		return !0;
+	}
+	get name() {
+		return this._name;
+	}
+	set name(e) {
+		this._name = e, this.notify(l.naming);
+	}
+	get hasIndexOnLabel() {
+		return !0;
+	}
+	get labelExtension() {}
+	get label() {
+		if (this.name !== void 0) return this.name;
+		let e = t(this.typeName);
+		if (this.hasIndexOnLabel) {
+			let t = n(this);
+			t !== void 0 && (e += ` ${t + 1}`);
+		}
+		return this.labelExtension !== void 0 && (e += ` (${this.labelExtension})`), e;
+		function n(e) {
+			let { parent: t } = e;
+			if (t === void 0) return;
+			let n = 0;
+			for (let r of t.children) {
+				if (r === e) break;
+				e.getTypeName() === r.getTypeName() && (n += 1);
+			}
+			return n;
+		}
+	}
+	get canChangeColor() {
+		return !0;
+	}
+	get hasIconColor() {
+		return !0;
+	}
+	get color() {
+		return this._color === void 0 && (this._color = x().clone()), this._color;
+	}
+	setColor(e) {
+		this._color === void 0 ? this._color = new E(e) : this._color.set(e), this.notify(l.color);
+	}
+	get canBeSelected() {
+		return !0;
+	}
+	get isSelected() {
+		return this._isSelected;
+	}
+	set isSelected(e) {
+		this._isSelected = e;
+	}
+	setSelected(e) {
+		return this.isSelected !== e && (this.isSelected = e, this.notify(l.selected), !0);
+	}
+	get canBeActive() {
+		return !1;
+	}
+	get isActive() {
+		return this._isActive;
+	}
+	set isActive(e) {
+		this._isActive = e;
+	}
+	setActive() {
+		if (!this.isActive && this.canBeActive) {
+			if (this.parent !== void 0) for (let e of this.parent.children) e !== this && e.getTypeName() === this.getTypeName() && e.canBeActive && e.isActive && (e.isActive = !1, e.notify(l.active));
+			this.isActive = !0, this.notify(l.active);
+		}
+	}
+	get isExpanded() {
+		return this._isExpanded;
+	}
+	set isExpanded(e) {
+		this._isExpanded !== e && (this._isExpanded = e, this.notify(l.expanded));
+	}
+	get canBeRemoved() {
+		return !0;
+	}
+	canBeSetVisibleNow(e) {
+		return !0;
+	}
+	get isLegal() {
+		return !0;
+	}
+	notifyCore(e) {
+		if (this.views.notify(this, e), e.isChanged(l.renderStyle) && this.isRenderStyleRoot) {
+			let t = e.getChangedDescription(l.renderStyle);
+			if (t !== void 0) {
+				let e = new g(t);
+				this.notifyDescendants(e);
+			}
+		}
+		e.isChanged(l.visibleState, l.active, l.selected, l.childAdded, l.childDeleted) && c(this)?.updateAllCommands(), this.hasPanelInfo && c(this)?.notifyPanel(this, e), S(this.updateSignal);
+	}
+	createTransaction(e) {}
+	clone(e) {
+		throw Error("Method not implemented.");
+	}
+	copyFrom(e, t) {
+		t === void 0 && (this.uniqueId = e.uniqueId), (t === void 0 || t === l.color) && this.canChangeColor && this.setColor(e.color), (t === void 0 || t === l.naming) && (this.name = e.name), (t === void 0 || t === l.renderStyle) && (this._renderStyle = e._renderStyle?.clone());
+	}
+	get hasPanelInfo() {
+		return !1;
+	}
+	getPanelInfo() {}
+	getPanelInfoStyle() {
+		return new _({
+			bottom: 58,
+			left: 16,
+			padding: 8
+		});
+	}
+	getPanelToolbar() {
+		return [
+			new d(),
+			new p(),
+			new f(this)
+		];
+	}
+	getContextMenu() {}
+	get icon() {}
+	getBoundingBox() {
+		let e = new T().makeEmpty();
+		return this.expandBoundingBox(e), e;
+	}
+	expandBoundingBox(e) {}
+	dispose() {
+		this.views.dispose();
+		for (let e of this._disposables) e();
+		r(this._disposables);
+	}
+	get renderStyleRoot() {}
+	get isRenderStyleRoot() {
+		return !1;
+	}
+	createRenderStyle() {}
+	verifyRenderStyle(e) {}
+	getVisibleState(e) {
+		if (e === void 0 && (e = c(this), e === void 0)) return u.Disabled;
+		let t = 0, n = 0, r = 0;
+		for (let i of this.children) {
+			let a = i.getVisibleState(e);
+			if (a !== u.Disabled && (t++, a === u.All ? n++ : (a === u.None || a === u.CanNotBeVisibleNow) && r++, r < t && t < n)) return u.Some;
+		}
+		return t === 0 ? u.Disabled : t === n ? u.All : t === r ? this.canBeSetVisibleNow(e) ? u.None : u.CanNotBeVisibleNow : u.Some;
+	}
+	setVisible(e, t = void 0, n = !0) {
+		if (t === void 0 && (t = c(this), t === void 0)) return !1;
+		let r = this.getVisibleState(t);
+		if (r === u.Disabled || r === u.None && !this.canBeSetVisibleNow(t)) return !1;
+		let i = !1;
+		for (let n of this.children) n.setVisible(e, t, !1) && (i = !0);
+		return i ? (n && this.notifyVisibleStateChange(), !0) : !1;
+	}
+	notify(e) {
+		(typeof e == "symbol" || e instanceof m) && (e = new g(e)), this.notifyCore(e);
+	}
+	notifyDescendants(e) {
+		(typeof e == "symbol" || e instanceof m) && (e = new g(e));
+		for (let t of this.getDescendants()) t.notify(e);
+	}
+	notifyVisibleStateChange() {
+		let e = new g(l.visibleState);
+		this.notify(e);
+		for (let t of this.getAncestors()) t.notify(e);
+		for (let t of this.getDescendants()) t.notify(e);
+	}
+	toggleVisible(e) {
+		let t = this.getVisibleState(e);
+		t === u.None ? this.setVisible(!0, e) : (t === u.Some || t === u.All) && this.setVisible(!1, e);
+	}
+	isVisible(e) {
+		let t = this.getVisibleState(e);
+		return t === u.Some || t === u.All;
+	}
+	get children() {
+		return this._children;
+	}
+	get childCount() {
+		return this._children.length;
+	}
+	get childIndex() {
+		if (this.parent === void 0) return;
+		let e = this.parent.children.indexOf(this);
+		return e === -1 ? void 0 : e;
+	}
+	get parent() {
+		return this._parent;
+	}
+	get root() {
+		return this.parent === void 0 ? this : this.parent.root;
+	}
+	get isRoot() {
+		return !1;
+	}
+	get hasParent() {
+		return this._parent !== void 0;
+	}
+	hasChildByType(e) {
+		return this.getChildByType(e) !== void 0;
+	}
+	getChild(e) {
+		return this._children[e];
+	}
+	getChildByType(e) {
+		for (let t of this.children) if (n(t, e)) return t;
+	}
+	getActiveChildByType(e) {
+		for (let t of this.children) if (t.isActive && n(t, e)) return t;
+	}
+	*getChildrenByType(e) {
+		for (let t of this.children) n(t, e) && (yield t);
+	}
+	*getDescendants() {
+		for (let e of this.children) yield e, yield* e.getDescendants();
+	}
+	*getThisAndDescendants() {
+		yield this;
+		for (let e of this.getDescendants()) yield e;
+	}
+	*getDescendantsByType(e) {
+		for (let t of this.getDescendants()) n(t, e) && (yield t);
+	}
+	*getThisAndDescendantsByType(e) {
+		for (let t of this.getThisAndDescendants()) n(t, e) && (yield t);
+	}
+	getDescendantByType(e) {
+		for (let t of this.getDescendants()) if (n(t, e)) return t;
+	}
+	hasDescendantByType(e) {
+		return this.getDescendants().some((t) => n(t, e));
+	}
+	getThisOrDescendantByUniqueId(e) {
+		for (let t of this.getThisAndDescendants()) if (t.uniqueId === e) return t;
+	}
+	getSelectedDescendant() {
+		for (let e of this.getThisAndDescendants()) if (e.isSelected) return e;
+	}
+	getSelectedDescendantByType(e) {
+		for (let t of this.getDescendantsByType(e)) if (t.isSelected) return t;
+	}
+	getActiveDescendantByType(e) {
+		for (let t of this.getDescendantsByType(e)) if (t.isActive) return t;
+	}
+	*getAncestors() {
+		let e = this.parent;
+		for (; e !== void 0;) yield e, e = e.parent;
+	}
+	*getThisAndAncestors() {
+		yield this;
+		let e = this.parent;
+		for (; e !== void 0;) yield e, e = e.parent;
+	}
+	getAncestorByType(e) {
+		for (let t of this.getAncestors()) if (n(t, e)) return t;
+	}
+	getThisOrAncestorByType(e) {
+		for (let t of this.getThisAndAncestors()) if (n(t, e)) return t;
+	}
+	addChildRaw(e, t) {
+		if (e.hasParent) throw Error(`The child ${e.getTypeName()} already has a parent`);
+		if (e === this) throw Error(`Trying to add illegal child ${e.getTypeName()}`);
+		t !== void 0 && t >= 0 && t < this._children.length ? i(this._children, t, e) : this._children.push(e), e._parent = this;
+	}
+	addChild(e, t) {
+		this.addChildRaw(e, t), this.notify(l.childAdded), e.notify(l.added);
+	}
+	removeRaw() {
+		let { childIndex: e } = this;
+		if (e === void 0) throw Error(`The child ${this.getTypeName()} is not child of it's parent`);
+		return r(this._children), this.dispose(), this.parent !== void 0 && (a(this.parent.children, e), this._parent = void 0), !0;
+	}
+	remove(e = !0) {
+		if (e && !this.canBeRemoved) return !1;
+		for (let e = this.children.length - 1; e >= 0; e--) this.children[e].remove(!1);
+		let { parent: t, root: n } = this;
+		return this.notify(l.deleting), this.removeRaw(), t?.notify(l.childDeleted), this.notify(l.deleted), n !== void 0 && n !== this && n.views.notifyListeners(this, new g(l.deleted)), !0;
+	}
+	getRenderStyle() {
+		let e = this.renderStyleRoot;
+		return e !== void 0 && e !== this ? e.getRenderStyle() : (this._renderStyle === void 0 && (this._renderStyle = this.createRenderStyle()), this._renderStyle !== void 0 && this.verifyRenderStyle(this._renderStyle), this._renderStyle);
+	}
+	setRenderStyle(e = void 0) {
+		this._renderStyle = e;
+	}
+	getTypeName() {
+		return e(this.typeName) ? this.typeName.key : this.typeName.untranslated;
+	}
+	supportsColorType(e, t) {
+		switch (e) {
+			case h.Specified:
+			case h.Parent:
+			case h.Black:
+			case h.White: return !0;
+			case h.ColorMap: return t;
+			default: return !1;
+		}
+	}
+	getColorByColorType(e) {
+		switch (e) {
+			case h.Specified: return this.color;
+			case h.Parent:
+				if (this.parent !== void 0) return this.parent.color;
+				break;
+			case h.Black: return y;
+		}
+		return b;
+	}
+	addDisposable(e) {
+		this._disposables.push(e);
+	}
+	addEffect(e) {
+		this.addDisposable(C(() => {
+			e();
+		}));
+	}
+};
+//#endregion
+export { D as DomainObject };

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

@@ -0,0 +1,11 @@
+import { TranslationInput } from '../utilities/translation/TranslateInput';
+import { IconName } from '../utilities/types';
+import { DomainObject } from './DomainObject';
+export declare class FolderDomainObject extends DomainObject {
+    get typeName(): TranslationInput;
+    get isVisibleInTree(): boolean;
+    get hasIconColor(): boolean;
+    get hasIndexOnLabel(): boolean;
+    get icon(): IconName;
+    clone(what?: symbol): DomainObject;
+}

package/dist/foundation/domainObjects/FolderDomainObject.js

@@ -0,0 +1,25 @@
+import { DomainObject as e } from "./DomainObject.js";
+//#region libs/shared/reveal-components/src/foundation/domainObjects/FolderDomainObject.ts
+var t = class t extends e {
+	get typeName() {
+		return { untranslated: "Folder" };
+	}
+	get isVisibleInTree() {
+		return this.children.length > 0;
+	}
+	get hasIconColor() {
+		return !1;
+	}
+	get hasIndexOnLabel() {
+		return !1;
+	}
+	get icon() {
+		return "FolderFilled";
+	}
+	clone(e) {
+		let n = new t();
+		return n.copyFrom(this, e), n;
+	}
+};
+//#endregion
+export { t as FolderDomainObject };