@cognite/reveal-components 1.0.0

package/dist/foundation/renderTarget/convertCoordinates.d.ts

@@ -0,0 +1,4 @@
+import { Matrix4, Vector3 } from 'three';
+export declare const VIEWER_TO_CDF_TRANSFORMATION: Matrix4;
+export declare function convertFromViewerCoordinates(point: Vector3): Vector3;
+export declare function convertToViewerCoordinates(point: Vector3): Vector3;

package/dist/foundation/renderTarget/convertCoordinates.js

@@ -0,0 +1,13 @@
+import { CDF_TO_VIEWER_TRANSFORMATION as e } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/foundation/renderTarget/convertCoordinates.ts
+var t = e.clone().invert();
+function n(e) {
+	let n = e.clone();
+	return n.applyMatrix4(t), n;
+}
+function r(t) {
+	let n = t.clone();
+	return n.applyMatrix4(e), n;
+}
+//#endregion
+export { t as VIEWER_TO_CDF_TRANSFORMATION, n as convertFromViewerCoordinates, r as convertToViewerCoordinates };

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

@@ -0,0 +1,32 @@
+import { CadDomainObject } from '../../../domains/reveal/cad/CadDomainObject';
+import { ILazyLoader } from '../tree-node-type/i-lazy-loader';
+import { TreeNodeType } from '../tree-node-type/tree-node-type';
+import { CadTreeNode } from './cad-tree-node';
+import { RevisionId } from './cad-types';
+import { INodesAndInstanceMappingsSdk } from './nodes-and-instance-mappings-sdk/i-nodes-and-instance-mappings-sdk';
+export type CadLazyLoaderOptions = {
+    showInstanceMappings?: boolean;
+    listNodesLimit?: number;
+    domainObject?: CadDomainObject;
+};
+export declare class CadLazyLoader implements ILazyLoader {
+    private readonly _sdk;
+    private readonly _revisionId;
+    private _root;
+    private readonly _listNodesLimit;
+    private _showInstanceMappings;
+    private readonly _domainObject;
+    get root(): CadTreeNode | undefined;
+    constructor(sdk: INodesAndInstanceMappingsSdk, revisionId: RevisionId, { showInstanceMappings, listNodesLimit, domainObject, }?: CadLazyLoaderOptions);
+    get revisionId(): RevisionId;
+    onNodeLoaded(child: TreeNodeType, parent?: TreeNodeType): void;
+    loadInitialRoot(): Promise<TreeNodeType>;
+    loadChildren(parent: TreeNodeType): Promise<CadTreeNode[] | undefined>;
+    loadSiblings(sibling: TreeNodeType): Promise<TreeNodeType[] | undefined>;
+    forceNodeInTree(nodeId: number): Promise<CadTreeNode | undefined>;
+    private createCadTreeNode;
+    private deleteInstanceMapping;
+    private getNodeIdToInstanceMappingMap;
+    private list3DNodeAncestors;
+    private insertAncestors;
+}

package/dist/foundation/treeNodes/cad-tree-node/cad-lazy-loader.js

@@ -0,0 +1,117 @@
+import { CheckboxState as e } from "../../utilities/types.js";
+import { concatenateMapValues as t } from "../../../utilities/map/concatenateMapValues.js";
+import { onSelectNode as n, onToggleNode as r } from "../tree-node/tree-node-functions.js";
+import { CadTreeNode as i } from "./cad-tree-node.js";
+import { updateHiddenNodes as a, updateSelectedNodes as o } from "./cad-node-update-styling.js";
+//#region libs/shared/reveal-components/src/foundation/treeNodes/cad-tree-node/cad-lazy-loader.ts
+var s = class {
+	_sdk;
+	_revisionId;
+	_root;
+	_listNodesLimit;
+	_showInstanceMappings;
+	_domainObject;
+	get root() {
+		return this._root;
+	}
+	constructor(e, t, { showInstanceMappings: n = !1, listNodesLimit: r = 100, domainObject: i } = {}) {
+		this._sdk = e, this._revisionId = t, this._listNodesLimit = r, this._showInstanceMappings = n, this._domainObject = i;
+	}
+	get revisionId() {
+		return this._revisionId;
+	}
+	onNodeLoaded(t, n) {
+		t.checkboxState = n === void 0 ? e.All : n.checkboxState;
+	}
+	async loadInitialRoot() {
+		if (this._root !== void 0) return this._root;
+		let e = (await this._sdk.list3DNodes(this._revisionId.modelId, this._revisionId.revisionId, {
+			depth: 0,
+			limit: 1
+		})).items[0], t = await this.getNodeIdToInstanceMappingMap([e]), n = this.createCadTreeNode(e, t);
+		if (this.onNodeLoaded(n), n.isExpanded = !0, n.needLoadChildren && n.isParent && (await n.loadChildren(this), n.childCount === 1)) for (let e of n.getChildren()) e.isExpanded = !0;
+		return this._root = n, this._root;
+	}
+	async loadChildren(e) {
+		if (!(e instanceof i)) throw Error("Parent node should be a CadTreeNode");
+		let t = await this._sdk.list3DNodes(this._revisionId.modelId, this._revisionId.revisionId, {
+			depth: 1,
+			limit: this._listNodesLimit,
+			nodeId: e.nodeId
+		});
+		t.items = t.items.filter((t) => t.id !== e.nodeId);
+		let n = await this.getNodeIdToInstanceMappingMap(t.items), r = t.items.map((e) => this.createCadTreeNode(e, n));
+		if (t.nextCursor !== void 0) {
+			let e = r[r.length - 1];
+			e.loadSiblingCursor = t.nextCursor;
+		}
+		return r;
+	}
+	async loadSiblings(e) {
+		if (!(e instanceof i)) throw Error("Sibling node should be a CadTreeNode");
+		let t = e.parent;
+		if (!(t instanceof i)) throw Error("Parent of sibling node should be a CadTreeNode");
+		let n = await this._sdk.list3DNodes(this._revisionId.modelId, this._revisionId.revisionId, {
+			depth: 1,
+			limit: this._listNodesLimit,
+			nodeId: t.nodeId,
+			cursor: e.loadSiblingCursor
+		}), r = await this.getNodeIdToInstanceMappingMap(n.items);
+		n.items = n.items.filter((e) => e.id !== t.nodeId);
+		let a = n.items.map((e) => this.createCadTreeNode(e, r));
+		if (n.nextCursor !== void 0) {
+			let e = a[a.length - 1];
+			e.loadSiblingCursor = n.nextCursor;
+		}
+		return a;
+	}
+	async forceNodeInTree(e) {
+		let t = this._root;
+		if (t === void 0) return;
+		let n = t.getThisOrDescendantByNodeId(e);
+		return n === void 0 ? await this.list3DNodeAncestors(e).then(async (e) => {
+			if (t === void 0) return;
+			let n = await this.getNodeIdToInstanceMappingMap(e), r = this.insertAncestors(t, e, n);
+			if (r !== void 0) return r.expandAllAncestors(), r;
+		}) : (n.expandAllAncestors(), n);
+	}
+	createCadTreeNode(e, t) {
+		let s = new i(e, { instanceMappingOptions: this._showInstanceMappings ? {
+			instanceMappings: t?.get(e.id) ?? [],
+			deleteInstanceMapping: (e) => this.deleteInstanceMapping(e)
+		} : void 0 }), c = this._domainObject;
+		return c !== void 0 && (s.onSelect = () => {
+			n(s, !1, !1) && o(c, s.getRoot());
+		}, s.toggleVisible = () => {
+			r(s) && a(c, s.getRoot());
+		}), s;
+	}
+	deleteInstanceMapping(e) {
+		return this._sdk.deleteInstanceMapping(this._revisionId.modelId, this._revisionId.revisionId, e);
+	}
+	async getNodeIdToInstanceMappingMap(e) {
+		if (this._showInstanceMappings === !1) return;
+		let n = await this._sdk.filterInstanceMappings(this._revisionId.modelId, this._revisionId.revisionId, e);
+		return t(n.items.map((e) => [e.node.nodeId, e]));
+	}
+	async list3DNodeAncestors(e) {
+		return (await this._sdk.list3DNodeAncestors(this._revisionId.modelId, this._revisionId.revisionId, e)).items;
+	}
+	insertAncestors(e, t, n) {
+		if (t.length === 0) return;
+		if (t[0].id !== e.nodeId) throw Error("The root node is not the same as the current node");
+		let r = e;
+		for (let e = 1; e < t.length; e++) {
+			let i = t[e], a = r.getChildByNodeId(i.id);
+			if (a !== void 0) {
+				r = a;
+				continue;
+			}
+			let o = this.createCadTreeNode(i, n), s = r.getLastChild();
+			s?.needLoadSiblings && (o.loadSiblingCursor = s.loadSiblingCursor, s.loadSiblingCursor = void 0), r.addChild(o), r.needLoadChildren && (r.needLoadChildren = !1, r.needLoadSiblings = !0), o.needLoadSiblings = !0, this.onNodeLoaded?.(o, r), r = o;
+		}
+		return r;
+	}
+};
+//#endregion
+export { s as CadLazyLoader };

package/dist/foundation/treeNodes/cad-tree-node/cad-node-update-styling.d.ts

@@ -0,0 +1,6 @@
+import { CadDomainObject } from '../../../domains/reveal/cad/CadDomainObject';
+import { CadTreeNode } from './cad-tree-node';
+export declare const HIDDEN_NODES: symbol;
+export declare const SELECTED_NODES: symbol;
+export declare function updateHiddenNodes(domainObject: CadDomainObject, root: CadTreeNode): void;
+export declare function updateSelectedNodes(domainObject: CadDomainObject, root: CadTreeNode): void;

package/dist/foundation/treeNodes/cad-tree-node/cad-node-update-styling.js

@@ -0,0 +1,47 @@
+import { CheckboxState as e } from "../../utilities/types.js";
+import { CadTreeNode as t } from "./cad-tree-node.js";
+import { DefaultNodeAppearance as n, IndexSet as r, NumericRange as i, TreeIndexNodeCollection as a } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/foundation/treeNodes/cad-tree-node/cad-node-update-styling.ts
+var o = Symbol("hiddenNodes"), s = Symbol("selectedNodes");
+function c(e, t) {
+	let s = new r(), c = !1;
+	for (let e of u(t)) c = !0, s.addRange(new i(e.treeIndex, e.subtreeSize));
+	let l = e.getStyledNodeCollections(o);
+	if (l !== void 0 && l.length > 0) {
+		d(l[0].collection, s, c);
+		return;
+	}
+	if (!c) return;
+	let f = new a(s);
+	e.addStyledNodeCollections(o, [{
+		collection: f,
+		appearance: n.Hidden
+	}]);
+}
+function l(e, o) {
+	let c = new r(), l = !1;
+	for (let e of o.getThisAndDescendantsByType(t)) e.isSelected && (l = !0, c.addRange(new i(e.treeIndex, e.subtreeSize)));
+	let u = e.getStyledNodeCollections(s);
+	if (u !== void 0 && u.length > 0) {
+		d(u[0].collection, c, l);
+		return;
+	}
+	if (!l) return;
+	let f = e.getDefaultStyling().renderGhosted === !0, p = new a(c), m = f ? { renderGhosted: !1 } : n.Highlighted;
+	e.addStyledNodeCollections(s, [{
+		collection: p,
+		appearance: m
+	}]);
+}
+function* u(n) {
+	if (n.checkboxState === e.None) {
+		yield n;
+		return;
+	}
+	if (n.checkboxState !== e.All) for (let e of n.getChildrenByType(t)) yield* u(e);
+}
+function d(e, t, n) {
+	e instanceof a && (n ? e.updateSet(t) : e.clear());
+}
+//#endregion
+export { o as HIDDEN_NODES, s as SELECTED_NODES, c as updateHiddenNodes, l as updateSelectedNodes };

package/dist/foundation/treeNodes/cad-tree-node/cad-tree-node-view-adapter.d.ts

@@ -0,0 +1,42 @@
+import { Signal } from '@cognite/signal-utils';
+import { IconColor, IconName, CheckboxState } from '../../utilities/types';
+import { TreeNodeType } from '../tree-node-type/tree-node-type';
+import { CadLazyLoader } from './cad-lazy-loader';
+import { CadTreeNode } from './cad-tree-node';
+import { RevisionId } from './cad-types';
+/**
+ * This adapter carries its own `CadLazyLoader` reference instead of
+ * relying on that ambient argument, so expanding a node several levels deep
+ * still triggers lazy loading correctly.
+ */
+export declare class CadTreeNodeViewAdapter implements TreeNodeType {
+    private readonly _node;
+    private readonly _loader;
+    constructor(node: CadTreeNode, loader: CadLazyLoader);
+    /** The wrapped CAD node, e.g. for reading `nodeId` when showing node info. */
+    get node(): CadTreeNode;
+    /** The model/revision this node's CAD model belongs to. */
+    get revisionId(): RevisionId;
+    get updateSignal(): Signal<number>;
+    get id(): TreeNodeType['id'];
+    get label(): string;
+    get isSelected(): boolean;
+    set isSelected(value: boolean);
+    get isExpanded(): boolean;
+    set isExpanded(value: boolean);
+    get isParent(): boolean;
+    get hasBoldLabel(): boolean | undefined;
+    get hasInfoIcon(): boolean | undefined;
+    get icon(): IconName;
+    get iconColor(): IconColor;
+    get isCheckboxEnabled(): boolean | undefined;
+    get checkboxState(): CheckboxState | undefined;
+    set checkboxState(value: CheckboxState | undefined);
+    get tooltip(): string | undefined;
+    get isLoadingChildren(): boolean | undefined;
+    get isLoadingSiblings(): boolean | undefined;
+    get needLoadSiblings(): boolean | undefined;
+    get onSelect(): (() => void) | undefined;
+    get toggleVisible(): (() => void) | undefined;
+    getChildren(): Generator<TreeNodeType>;
+}

package/dist/foundation/treeNodes/cad-tree-node/cad-tree-node-view-adapter.js

@@ -0,0 +1,83 @@
+import { CadTreeNode as e } from "./cad-tree-node.js";
+//#region libs/shared/reveal-components/src/foundation/treeNodes/cad-tree-node/cad-tree-node-view-adapter.ts
+var t = class t {
+	_node;
+	_loader;
+	constructor(e, t) {
+		this._node = e, this._loader = t;
+	}
+	get node() {
+		return this._node;
+	}
+	get revisionId() {
+		return this._loader.revisionId;
+	}
+	get updateSignal() {
+		return this._node.updateSignal;
+	}
+	get id() {
+		return this._node.id;
+	}
+	get label() {
+		return this._node.label;
+	}
+	get isSelected() {
+		return this._node.isSelected;
+	}
+	set isSelected(e) {
+		this._node.isSelected = e;
+	}
+	get isExpanded() {
+		return this._node.isExpanded;
+	}
+	set isExpanded(e) {
+		this._node.isExpanded = e;
+	}
+	get isParent() {
+		return this._node.isParent;
+	}
+	get hasBoldLabel() {
+		return this._node.hasBoldLabel;
+	}
+	get hasInfoIcon() {
+		return this._node.hasInfoIcon;
+	}
+	get icon() {
+		return this._node.icon;
+	}
+	get iconColor() {
+		return this._node.iconColor;
+	}
+	get isCheckboxEnabled() {
+		return this._node.isCheckboxEnabled;
+	}
+	get checkboxState() {
+		return this._node.checkboxState;
+	}
+	set checkboxState(e) {
+		this._node.checkboxState = e;
+	}
+	get tooltip() {
+		return this._node.tooltip;
+	}
+	get isLoadingChildren() {
+		return this._node.isLoadingChildren;
+	}
+	get isLoadingSiblings() {
+		return this._node.isLoadingSiblings;
+	}
+	get needLoadSiblings() {
+		return this._node.needLoadSiblings;
+	}
+	get onSelect() {
+		return this._node.onSelect;
+	}
+	get toggleVisible() {
+		return this._node.toggleVisible;
+	}
+	*getChildren() {
+		for (let n of this._node.getChildren(this._loader)) n instanceof e && (yield new t(n, this._loader));
+	}
+};
+//#endregion
+export { t as CadTreeNodeViewAdapter };

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

@@ -0,0 +1,42 @@
+import { CadNodeMapping } from '../../../data-providers';
+import { UniqueId } from '../../utilities/types';
+import { TreeNode } from '../tree-node/tree-node';
+import { SubsetOfNode3D } from './cad-types';
+export type DeleteInstanceMappingDelegate = (instanceMapping: CadNodeMapping) => Promise<void>;
+export declare class CadTreeNode extends TreeNode {
+    private readonly _nodeId;
+    private readonly _treeIndex;
+    private readonly _subtreeSize;
+    private _instanceMappings;
+    private readonly _deleteInstanceMappingCallback;
+    private _loadSiblingCursor?;
+    onSelect?: () => void;
+    toggleVisible?: () => void;
+    constructor(node: SubsetOfNode3D, options?: {
+        instanceMappingOptions?: {
+            instanceMappings: CadNodeMapping[];
+            deleteInstanceMapping: DeleteInstanceMappingDelegate;
+        };
+    });
+    get id(): UniqueId;
+    get nodeId(): number;
+    get treeIndex(): number;
+    get subtreeSize(): number;
+    get loadSiblingCursor(): string | undefined;
+    set loadSiblingCursor(value: string | undefined);
+    areEqual(child: TreeNode): boolean;
+    getChildByNodeId(nodeId: number): CadTreeNode | undefined;
+    getThisOrDescendantByNodeId(nodeId: number): CadTreeNode | undefined;
+    getThisOrDescendantByTreeIndex(treeIndex: number): CadTreeNode | undefined;
+    getThisOrDescendantsByTreeIndices(treeIndices: number[]): Generator<CadTreeNode>;
+    getRoot(): CadTreeNode;
+    getInstanceMappings(): readonly Readonly<CadNodeMapping>[];
+    addInstanceMapping(assetMapping: CadNodeMapping): void;
+    deleteInstanceMapping(instanceMapping: CadNodeMapping): Promise<void>;
+    /**
+     * This function ensure same conversion of treeIndex to UniqueId
+     * @param treeIndex - The tree index to convert to string
+     * @returns The tree index as a UniqueId
+     */
+    static treeIndexToString(treeIndex: number): UniqueId;
+}

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

@@ -0,0 +1,68 @@
+import { createInstanceKey as e } from "../../../data-providers/cache/idAndKeyTranslation.js";
+import { TreeNode as t } from "../tree-node/tree-node.js";
+//#region libs/shared/reveal-components/src/foundation/treeNodes/cad-tree-node/cad-tree-node.ts
+var n = class n extends t {
+	_nodeId;
+	_treeIndex;
+	_subtreeSize;
+	_instanceMappings;
+	_deleteInstanceMappingCallback;
+	_loadSiblingCursor;
+	onSelect;
+	toggleVisible;
+	constructor(e, t) {
+		super(), this._nodeId = e.id, this._treeIndex = e.treeIndex, this._subtreeSize = e.subtreeSize, this._instanceMappings = t?.instanceMappingOptions?.instanceMappings, this.label = e.name === "" ? e.id.toString() : e.name, this.needLoadChildren = e.subtreeSize > 1, this.hasInfoIcon = !0, this._deleteInstanceMappingCallback = t?.instanceMappingOptions?.deleteInstanceMapping;
+	}
+	get id() {
+		return n.treeIndexToString(this.treeIndex);
+	}
+	get nodeId() {
+		return this._nodeId;
+	}
+	get treeIndex() {
+		return this._treeIndex;
+	}
+	get subtreeSize() {
+		return this._subtreeSize;
+	}
+	get loadSiblingCursor() {
+		return this._loadSiblingCursor;
+	}
+	set loadSiblingCursor(e) {
+		this._loadSiblingCursor = e, this.needLoadSiblings = e !== void 0;
+	}
+	areEqual(e) {
+		return e instanceof n && e.nodeId === this.nodeId && e.treeIndex === this.treeIndex;
+	}
+	getChildByNodeId(e) {
+		for (let t of this.getChildrenByType(n)) if (t.nodeId === e) return t;
+	}
+	getThisOrDescendantByNodeId(e) {
+		for (let t of this.getThisAndDescendantsByType(n)) if (t.nodeId === e) return t;
+	}
+	getThisOrDescendantByTreeIndex(e) {
+		for (let t of this.getThisAndDescendantsByType(n)) if (t.treeIndex === e) return t;
+	}
+	*getThisOrDescendantsByTreeIndices(e) {
+		for (let t of this.getThisAndDescendantsByType(n)) e.indexOf(t.treeIndex) >= 0 && (yield t);
+	}
+	getRoot() {
+		return this.parent !== void 0 && this.parent instanceof n ? this.parent.getRoot() : this;
+	}
+	getInstanceMappings() {
+		return [...this._instanceMappings ?? []];
+	}
+	addInstanceMapping(e) {
+		this._instanceMappings = [...this._instanceMappings ?? [], e], this.update();
+	}
+	async deleteInstanceMapping(t) {
+		if (this._instanceMappings === void 0) return;
+		let n = e(t.instance), r = this._instanceMappings.find((r) => n === e(r.instance) && r.node.nodeId === t.node.nodeId);
+		r !== void 0 && (this._instanceMappings = this._instanceMappings.filter((e) => e !== r), await this._deleteInstanceMappingCallback?.(t), this.update());
+	}
+	static treeIndexToString(e) {
+		return e.toString();
+	}
+};
+//#endregion
+export { n as CadTreeNode };

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

@@ -0,0 +1,10 @@
+export type SubsetOfNode3D = {
+    id: number;
+    treeIndex: number;
+    subtreeSize: number;
+    name: string;
+};
+export type RevisionId = {
+    modelId: number;
+    revisionId: number;
+};

package/dist/foundation/treeNodes/cad-tree-node/nodes-and-instance-mappings-sdk/classic-instance-mappings-sdk.d.ts

@@ -0,0 +1,12 @@
+import { CogniteClient } from '@cognite/sdk';
+import { CadNodeMapping } from '../../../../data-providers';
+import { SubsetOfNode3D } from '../cad-types';
+import { IInstanceMappingsSdk } from './i-nodes-and-instance-mappings-sdk';
+export declare class ClassicInstanceMappingsSdk implements IInstanceMappingsSdk {
+    private _sdk;
+    constructor(_sdk: CogniteClient);
+    filterInstanceMappings(modelId: number, revisionId: number, nodes: SubsetOfNode3D[]): Promise<{
+        items: CadNodeMapping[];
+    }>;
+    deleteInstanceMapping(modelId: number, revisionId: number, instanceMapping: CadNodeMapping): Promise<void>;
+}

package/dist/foundation/treeNodes/cad-tree-node/nodes-and-instance-mappings-sdk/classic-instance-mappings-sdk.js

@@ -0,0 +1,40 @@
+import { isClassicInstanceId as e } from "../../../../utilities/instanceIds/typeGuards.js";
+import { isDefined as t } from "../../../../utilities/isDefined.js";
+import "../../../../utilities/index.js";
+//#region libs/shared/reveal-components/src/foundation/treeNodes/cad-tree-node/nodes-and-instance-mappings-sdk/classic-instance-mappings-sdk.ts
+var n = class {
+	_sdk;
+	constructor(e) {
+		this._sdk = e;
+	}
+	async filterInstanceMappings(e, n, r) {
+		if (r.length === 0) return { items: [] };
+		let i = r.map((e) => e.id), a = this._sdk.assetMappings3D.filter(e, n, { filter: { nodeIds: i } }), o = {
+			getDmsInstances: !0,
+			filter: { nodeIds: i }
+		}, s = this._sdk.assetMappings3D.filter(e, n, o);
+		return { items: [...(await a).items, ...(await s).items].map((e) => {
+			if (e.treeIndex !== void 0 && e.subtreeSize !== void 0) return {
+				node: {
+					nodeId: e.nodeId,
+					treeIndex: e.treeIndex,
+					subtreeSize: e.subtreeSize
+				},
+				instance: e.assetInstanceId ?? e.assetId,
+				sourceType: "assetMapping"
+			};
+		}).filter(t) };
+	}
+	async deleteInstanceMapping(t, n, r) {
+		let i = e(r.instance) ? { assetId: r.instance } : {
+			assetId: 0,
+			assetInstanceId: r.instance
+		};
+		await this._sdk.assetMappings3D.delete(t, n, [{
+			nodeId: r.node.nodeId,
+			...i
+		}]);
+	}
+};
+//#endregion
+export { n as ClassicInstanceMappingsSdk };

package/dist/foundation/treeNodes/cad-tree-node/nodes-and-instance-mappings-sdk/i-nodes-and-instance-mappings-sdk.d.ts

@@ -0,0 +1,19 @@
+import { List3DNodesQuery, Node3D } from '@cognite/sdk';
+import { CadNodeMapping } from '../../../../data-providers';
+import { SubsetOfNode3D } from '../cad-types';
+export type INodesSdk = {
+    list3DNodes: (modelId: number, revisionId: number, query: List3DNodesQuery) => Promise<{
+        items: Node3D[];
+        nextCursor?: string;
+    }>;
+    list3DNodeAncestors: (modelId: number, revisionId: number, nodeId: number) => Promise<{
+        items: Node3D[];
+    }>;
+};
+export type IInstanceMappingsSdk = {
+    filterInstanceMappings: (modelId: number, revisionId: number, nodes: SubsetOfNode3D[]) => Promise<{
+        items: CadNodeMapping[];
+    }>;
+    deleteInstanceMapping: (modelId: number, revisionId: number, instanceMapping: CadNodeMapping) => Promise<void>;
+};
+export type INodesAndInstanceMappingsSdk = INodesSdk & IInstanceMappingsSdk;

package/dist/foundation/treeNodes/cad-tree-node/nodes-and-instance-mappings-sdk/nodes-and-instance-mappings-sdk.d.ts

@@ -0,0 +1,20 @@
+import { CogniteClient, List3DNodesQuery, Node3D } from '@cognite/sdk';
+import { CadNodeMapping } from '../../../../data-providers';
+import { SubsetOfNode3D } from '../cad-types';
+import { IInstanceMappingsSdk, INodesAndInstanceMappingsSdk } from './i-nodes-and-instance-mappings-sdk';
+export declare class NodesAndInstanceMappingsSdk implements INodesAndInstanceMappingsSdk {
+    private readonly _sdk;
+    private readonly _instanceMappingsSdk;
+    constructor(sdk: CogniteClient, instanceMappingsSdk: IInstanceMappingsSdk);
+    list3DNodes(modelId: number, revisionId: number, query: List3DNodesQuery): Promise<{
+        items: Node3D[];
+        nextCursor?: string;
+    }>;
+    list3DNodeAncestors(modelId: number, revisionId: number, nodeId: number): Promise<{
+        items: Node3D[];
+    }>;
+    filterInstanceMappings(modelId: number, revisionId: number, nodes: SubsetOfNode3D[]): Promise<{
+        items: CadNodeMapping[];
+    }>;
+    deleteInstanceMapping(modelId: number, revisionId: number, mapping: CadNodeMapping): Promise<void>;
+}

package/dist/foundation/treeNodes/cad-tree-node/nodes-and-instance-mappings-sdk/nodes-and-instance-mappings-sdk.js

@@ -0,0 +1,22 @@
+//#region libs/shared/reveal-components/src/foundation/treeNodes/cad-tree-node/nodes-and-instance-mappings-sdk/nodes-and-instance-mappings-sdk.ts
+var e = class {
+	_sdk;
+	_instanceMappingsSdk;
+	constructor(e, t) {
+		this._sdk = e, this._instanceMappingsSdk = t;
+	}
+	async list3DNodes(e, t, n) {
+		return await this._sdk.revisions3D.list3DNodes(e, t, n);
+	}
+	async list3DNodeAncestors(e, t, n) {
+		return await this._sdk.revisions3D.list3DNodeAncestors(e, t, n);
+	}
+	async filterInstanceMappings(e, t, n) {
+		return this._instanceMappingsSdk.filterInstanceMappings(e, t, n);
+	}
+	async deleteInstanceMapping(e, t, n) {
+		return this._instanceMappingsSdk.deleteInstanceMapping(e, t, n);
+	}
+};
+//#endregion
+export { e as NodesAndInstanceMappingsSdk };

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

@@ -0,0 +1 @@
+export type { TreeNodeType } from './tree-node-type/tree-node-type';

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

@@ -0,0 +1,4 @@
+import { TreeNode } from './tree-node';
+export declare function onKeyDown(root: TreeNode, event: KeyboardEvent, lastSelectedNodeRef: {
+    current: TreeNode | undefined;
+}): boolean;

package/dist/foundation/treeNodes/tree-node/tree-node-functions-on-key-down.js

@@ -0,0 +1,66 @@
+import { TreeNode as e } from "./tree-node.js";
+import { clearSelection as t, onToggleNode as n } from "./tree-node-functions.js";
+import { findIndex as r, findLastIndex as i } from "lodash-es";
+//#region libs/shared/reveal-components/src/foundation/treeNodes/tree-node/tree-node-functions-on-key-down.ts
+function a(e, n, r) {
+	if (n.key === "ArrowRight" || n.key === "ArrowLeft") return c(e, n.key === "ArrowRight"), !1;
+	if (n.key === "Escape") return t(e);
+	if (n.key === "Enter" || n.key === " ") return l(e);
+	if (n.key === "ArrowUp" || n.key === "ArrowDown") {
+		let t = n.key === "ArrowUp" ? -1 : 1, i = n.shiftKey;
+		return o(e, r, i, t);
+	}
+	return !1;
+}
+function o(e, t, n, r) {
+	let i = Array.from(e.getExpandedThisAndDescendants()), a = t.current, o = a === void 0 ? -1 : i.indexOf(a), c = a !== void 0 && a.isSelected && o >= 0;
+	if (c && n) {
+		let { minIndex: e, maxIndex: t } = s(i, o);
+		if (r < 0) {
+			if (t > o) return i[t].setSelected(!1);
+			if (e <= o) return e--, e < 0 ? !1 : i[e].setSelected();
+		} else if (e < o) return i[e].setSelected(!1);
+		else if (t >= o) return t++, t >= i.length ? !1 : i[t].setSelected();
+	}
+	c || (o = r < 0 ? u(i) : d(i), a = o >= 0 ? i[o] : void 0);
+	let l = !1;
+	if (a) {
+		let e = o + r;
+		if (e < 0 || e >= i.length) return !1;
+		let a = i[e];
+		!n && f(i, a) && (l = !0), a.setSelected() && (n || (t.current = a), l = !0);
+	}
+	return l;
+}
+function s(e, t) {
+	if (t < 0) throw Error("selectedIndex must be non-negative");
+	let n = t;
+	for (let r = t - 1; r >= 0 && e[r].isSelected; r--) n = r;
+	let r = t;
+	for (let n = t + 1; n < e.length && e[n].isSelected; n++) r = n;
+	return {
+		minIndex: n,
+		maxIndex: r
+	};
+}
+function c(e, t) {
+	for (let n of e.getExpandedThisAndDescendants()) n.isSelected && (n.isExpanded = t);
+}
+function l(t) {
+	let r = !1;
+	for (let i of t.getThisAndDescendantsByType(e)) i.isSelected && n(i) && (r = !0);
+	return r;
+}
+function u(e) {
+	return r(e, (e) => e.isSelected);
+}
+function d(e) {
+	return i(e, (e) => e.isSelected);
+}
+function f(e, t) {
+	let n = !1;
+	for (let r of e) r !== t && r.setSelected(!1) && (n = !0);
+	return n;
+}
+//#endregion
+export { a as onKeyDown };