@cognite/reveal-components 1.0.0

package/dist/ui/components/RevealToolbar/RuleBasedOutputsButton/RuleBasedOutputsButton.js

@@ -0,0 +1,95 @@
+import { BaseTooltipTrigger as e, CommandTooltipPopup as t, useCommandTooltipHandle as n } from "../../commandBased/buttons/PopupTriggerButton.js";
+import { generateEmptyRuleForSelection as r } from "../../RuleBasedOutputs/core/generateEmptyRuleForSelection.js";
+import { getRuleBasedById as i } from "../../RuleBasedOutputs/core/getRuleBasedById.js";
+import { RuleBasedOutputsButtonContext as a } from "./RuleBasedOutputsButton.context.js";
+import { useCallback as o, useContext as s, useEffect as c, useState as l } from "react";
+import { Fragment as u, jsx as d, jsxs as f } from "react/jsx-runtime";
+import { Button as p } from "@cognite/aura/components/button";
+import { IconPalette as m } from "@tabler/icons-react";
+import { Popover as h, PopoverContent as g, PopoverTrigger as _ } from "@cognite/aura/components/popover";
+//#region libs/shared/reveal-components/src/ui/components/RevealToolbar/RuleBasedOutputsButton/RuleBasedOutputsButton.tsx
+var v = ({ onRuleSetStylingChanged: v, onRuleSetSelectedChanged: y }) => {
+	let { useTranslation: b, use3dModels: x, useAssetMappedNodesForRevisions: S, useReveal3DResourcesStylingLoading: C, useFetchRuleInstances: w, RuleBasedOutputsSelector: T, RuleBasedSelectionItem: E } = s(a), { t: D } = b(), O = x().filter((e) => e.type === "cad"), [k, A] = l(), [j, M] = l(), [N, P] = l(), [F, I] = l(), [L, R] = l(!1), [z, B] = l(!1), { isInitialLoading: V, isFetched: H } = S(O), [U, W] = l(), G = C(), [K, q] = l(!1), { data: J } = w(), Y = V && !H, X = k === void 0 || !!j?.isEnabled;
+	c(() => {
+		I(J);
+	}, [J]), c(() => {
+		A(U), y !== void 0 && y(U), R(U !== void 0);
+	}, [U]), c(() => {
+		let e = N !== void 0 && N.length > 0 && G || !K;
+		R(e);
+	}, [
+		K,
+		N,
+		G,
+		U
+	]);
+	let Z = o((e) => {
+		let t = r(D({ key: "RULESET_NO_SELECTION" }));
+		F?.forEach((e) => {
+			e !== void 0 && (e.isEnabled = !1);
+		});
+		let n = i(e, F);
+		n === void 0 ? (t.isEnabled = !0, v !== void 0 && v(void 0)) : n.isEnabled = !0, M(t), W(n);
+	}, [
+		F,
+		j,
+		v,
+		y
+	]), Q = (e) => {
+		P(e), v !== void 0 && v(e?.map((e) => e.assetStylingGroup));
+	}, $ = n();
+	return F === void 0 || F.length === 0 ? /* @__PURE__ */ d(u, {}) : /* @__PURE__ */ f(u, { children: [/* @__PURE__ */ f(h, {
+		onOpenChange: (e) => {
+			B(e);
+		},
+		children: [/* @__PURE__ */ d(_, { render: /* @__PURE__ */ d(e, {
+			handle: $,
+			children: /* @__PURE__ */ d(p, {
+				disabled: Y,
+				"aria-label": "Select RuleSet",
+				variant: z || !X ? "default" : "ghost",
+				size: "icon-sm",
+				children: /* @__PURE__ */ d(m, { color: z || !X ? "white" : "black" })
+			})
+		}) }), /* @__PURE__ */ f(g, {
+			side: "right",
+			align: "start",
+			sideOffset: 12,
+			className: "max-h-[300px] overflow-auto mb-5",
+			children: [
+				/* @__PURE__ */ d("p", {
+					className: "text-xs font-medium text-muted-foreground px-2 py-1",
+					children: D({ key: "RULESET_SELECT_HEADER" })
+				}),
+				/* @__PURE__ */ d(E, {
+					id: "no-rule-selected",
+					label: D({ key: "RULESET_NO_SELECTION" }),
+					checked: X,
+					onChange: Z,
+					isLoading: L,
+					isEmptyRuleItem: !0
+				}, "no-rule-selected"),
+				F?.map((e) => /* @__PURE__ */ d(E, {
+					id: e?.rule?.properties.id,
+					label: e?.rule?.properties.name,
+					checked: e?.isEnabled,
+					onChange: Z,
+					isLoading: L,
+					isEmptyRuleItem: !1
+				}, e?.rule?.properties.id)),
+				F !== void 0 && F?.length > 0 && /* @__PURE__ */ d(T, {
+					onRuleSetChanged: Q,
+					onAllMappingsFetched: q,
+					ruleSet: k?.rule.properties
+				})
+			]
+		})]
+	}), /* @__PURE__ */ d(t, {
+		handle: $,
+		side: "right",
+		disabled: z,
+		children: D({ key: "RULESET_SELECT_HEADER" })
+	})] });
+};
+//#endregion
+export { v as RuleBasedOutputsButton };

package/dist/ui/components/RevealToolbar/SlicerButton/SlicerButton.context.d.ts

@@ -0,0 +1,11 @@
+import { Context } from 'react';
+import { use3dModels } from '../../../hooks/use3dModels';
+import { useTranslation } from '../../i18n/I18n';
+import { useReveal } from '../../RevealCanvas/ViewerContext';
+export type SlicerButtonDependencies = {
+    useReveal: typeof useReveal;
+    useTranslation: typeof useTranslation;
+    use3dModels: typeof use3dModels;
+};
+export declare const defaultSlicerButtonDependencies: SlicerButtonDependencies;
+export declare const SlicerButtonContext: Context<SlicerButtonDependencies>;

package/dist/ui/components/RevealToolbar/SlicerButton/SlicerButton.context.js

@@ -0,0 +1,12 @@
+import { useReveal as e } from "../../RevealCanvas/ViewerContext.js";
+import { useTranslation as t } from "../../i18n/I18n.js";
+import { use3dModels as n } from "../../../hooks/use3dModels.js";
+import { createContext as r } from "react";
+//#region libs/shared/reveal-components/src/ui/components/RevealToolbar/SlicerButton/SlicerButton.context.ts
+var i = {
+	useReveal: e,
+	useTranslation: t,
+	use3dModels: n
+}, a = r(i);
+//#endregion
+export { a as SlicerButtonContext, i as defaultSlicerButtonDependencies };

package/dist/ui/components/RevealToolbar/SlicerButton/SlicerButton.d.ts

@@ -0,0 +1,2 @@
+import { ReactElement } from 'react';
+export declare const SlicerButton: () => ReactElement;

package/dist/ui/components/RevealToolbar/SlicerButton/SlicerButton.js

@@ -0,0 +1,74 @@
+import { BaseTooltipTrigger as e, CommandTooltipPopup as t, useCommandTooltipHandle as n } from "../../commandBased/buttons/PopupTriggerButton.js";
+import { SlicerButtonContext as r } from "./SlicerButton.context.js";
+import { useContext as i, useEffect as a, useState as o } from "react";
+import { Fragment as s, jsx as c, jsxs as l } from "react/jsx-runtime";
+import { Button as u } from "@cognite/aura/components/button";
+import { IconSlice as d } from "@tabler/icons-react";
+import { Popover as f, PopoverContent as p, PopoverTrigger as m } from "@cognite/aura/components/popover";
+import { Slider as h } from "@cognite/aura/components/slider";
+import { Box3 as g, Plane as _, Vector3 as v } from "three";
+//#region libs/shared/reveal-components/src/ui/components/RevealToolbar/SlicerButton/SlicerButton.tsx
+var y = () => {
+	let { useReveal: y, useTranslation: b, use3dModels: x } = i(r), S = y(), { t: C } = b(), w = x(), [T, E] = o({
+		minHeight: 0,
+		maxHeight: 0,
+		topRatio: 1,
+		bottomRatio: 0
+	}), [D, O] = o(!1), k = n(), { minHeight: A, maxHeight: j, topRatio: M, bottomRatio: N } = T;
+	a(() => {
+		if (w.length === 0) return;
+		let e = new g();
+		w.forEach((t) => e.union(t.getModelBoundingBox(void 0, !0)));
+		let t = e.max.y, n = e.min.y;
+		(j !== t || A !== n) && E((e) => ({
+			maxHeight: t,
+			minHeight: n,
+			topRatio: e.topRatio,
+			bottomRatio: e.bottomRatio
+		}));
+	}, [w]);
+	function P(e) {
+		let [t, n] = e, r = [];
+		t !== 0 && r.push(new _(new v(0, 1, 0), -(A + t * (j - A)))), n !== 1 && r.push(new _(new v(0, -1, 0), A + n * (j - A))), S.setGlobalClippingPlanes(r), E({
+			minHeight: A,
+			maxHeight: j,
+			bottomRatio: t,
+			topRatio: n
+		});
+	}
+	return /* @__PURE__ */ l(s, { children: [/* @__PURE__ */ l(f, {
+		onOpenChange: O,
+		children: [/* @__PURE__ */ c(m, { render: /* @__PURE__ */ c(e, {
+			handle: k,
+			children: /* @__PURE__ */ c(u, {
+				variant: D ? "default" : "ghost",
+				size: "icon-sm",
+				"aria-label": "Slice models",
+				children: /* @__PURE__ */ c(d, { color: D ? "white" : "black" })
+			})
+		}) }), /* @__PURE__ */ c(p, {
+			side: "right",
+			align: "start",
+			sideOffset: 12,
+			className: "w-10 h-[480px] py-3 px-2 flex items-center justify-center overflow-hidden",
+			children: /* @__PURE__ */ c("div", {
+				className: "h-full w-6",
+				children: /* @__PURE__ */ c(h, {
+					min: 0,
+					max: 1,
+					step: .01,
+					value: [N, M],
+					onValueChange: P,
+					orientation: "vertical"
+				})
+			})
+		})]
+	}), /* @__PURE__ */ c(t, {
+		handle: k,
+		side: "right",
+		disabled: D,
+		children: C({ key: "SLICE_TOOLTIP" })
+	})] });
+};
+//#endregion
+export { y as SlicerButton };

package/dist/ui/components/RevealToolbar/index.d.ts

@@ -0,0 +1 @@
+export { RevealToolbar } from './RevealToolbar';

package/dist/ui/components/RevealToolbar/index.js

@@ -0,0 +1,2 @@
+import { RevealToolbar as e } from "./RevealToolbar.js";
+export { e as RevealToolbar };

package/dist/ui/components/RuleBasedOutputs/RuleBasedOutputsPanel.d.ts

@@ -0,0 +1,7 @@
+import { ReactElement } from 'react';
+import { RuleOutput } from './types';
+type RuleBasedOutputsPanelProps = {
+    ruleOutputs?: RuleOutput[];
+};
+export declare const RuleBasedOutputsPanel: ({ ruleOutputs, }: RuleBasedOutputsPanelProps) => ReactElement;
+export {};

package/dist/ui/components/RuleBasedOutputs/RuleBasedOutputsPanel.js

@@ -0,0 +1,28 @@
+import { withSuppressRevealEvents as e } from "../../higher-order-components/withSuppressRevealEvents.js";
+import { OutputPanelItem as t } from "./components/OutputPanelItem.js";
+import { ShowMore as n } from "./components/OutputPanelShowMore.js";
+import { useState as r } from "react";
+import { Fragment as i, jsx as a, jsxs as o } from "react/jsx-runtime";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/RuleBasedOutputsPanel.tsx
+var s = 5, c = e(({ className: e, style: t, children: n }) => /* @__PURE__ */ a("div", {
+	className: e,
+	style: t,
+	children: n
+})), l = ({ ruleOutputs: e }) => {
+	let [l, u] = r(!1);
+	return /* @__PURE__ */ a(i, { children: e !== void 0 && e?.length > 0 && /* @__PURE__ */ o(c, {
+		className: "flex flex-col gap-3.5 absolute bottom-4 left-4 min-w-[200px] max-w-[400px] rounded text-[13px] leading-[18px] outline-none bg-white text-foreground shadow-md justify-start p-2.5 overflow-y-auto",
+		style: { maxHeight: l ? "300px" : void 0 },
+		children: [e.map((e, n) => /* @__PURE__ */ a(i, { children: l || n <= 4 ? /* @__PURE__ */ a(t, {
+			index: n,
+			output: e
+		}) : /* @__PURE__ */ a(i, {}) })), e.length > s && /* @__PURE__ */ a(n, {
+			isShowMore: l,
+			onShowMore: () => {
+				u((e) => !e);
+			}
+		})]
+	}) });
+};
+//#endregion
+export { l as RuleBasedOutputsPanel };

package/dist/ui/components/RuleBasedOutputs/RuleBasedOutputsSelector.context.d.ts

@@ -0,0 +1,21 @@
+import { Context } from 'react';
+import { InternalId } from '@cognite/sdk';
+import { DmCadAssetMapping } from '../../../data-providers/cache/cad/assetMappingTypes';
+import { FdmConnectionWithNode } from '../../../data-providers/cache/types';
+import { CadModelOptions } from '../../../utilities/modelIds';
+import { use3dModels, useAssetMappedNodesForRevisions, useMappedEdgesForRevisions } from '../../hooks';
+import { useAll3dDirectConnectionsWithProperties } from '../../query';
+import { useFetchClassicAssetsByIds } from '../../query/useFetchClassicAssetsByIds';
+import { generateRuleBasedOutputs } from './core/generateRuleBasedOutputs';
+import { useGetDMConnectionWithNodeFromHybridMappingsQuery } from './hooks/useGetDMConnectionWithNodeFromHybridMappingsQuery';
+export type RuleBasedOutputsSelectorDependencies = {
+    use3dModels: typeof use3dModels;
+    useAssetMappedNodesForRevisions: (cadModels: CadModelOptions[]) => Pick<ReturnType<typeof useAssetMappedNodesForRevisions>, 'data' | 'isInitialLoading'>;
+    useMappedEdgesForRevisions: (cadModels: CadModelOptions[], enabled: boolean) => Pick<ReturnType<typeof useMappedEdgesForRevisions>, 'data' | 'isInitialLoading'>;
+    useAll3dDirectConnectionsWithProperties: (connectionWithNodeAndView: FdmConnectionWithNode[]) => Pick<ReturnType<typeof useAll3dDirectConnectionsWithProperties>, 'data' | 'isInitialLoading'>;
+    useGetDMConnectionWithNodeFromHybridMappingsQuery: (nodeWithDmIdsFromHybridMappings: DmCadAssetMapping[], models: CadModelOptions[]) => Pick<ReturnType<typeof useGetDMConnectionWithNodeFromHybridMappingsQuery>, 'data' | 'isInitialLoading'>;
+    useFetchClassicAssetsByIds: (assetIdsToFilter: InternalId[]) => Pick<ReturnType<typeof useFetchClassicAssetsByIds>, 'data' | 'isInitialLoading' | 'isFetched'>;
+    generateRuleBasedOutputs: typeof generateRuleBasedOutputs;
+};
+export declare const defaultRuleBasedOutputsSelectorDependencies: RuleBasedOutputsSelectorDependencies;
+export declare const RuleBasedOutputsSelectorContext: Context<RuleBasedOutputsSelectorDependencies>;

package/dist/ui/components/RuleBasedOutputs/RuleBasedOutputsSelector.context.js

@@ -0,0 +1,22 @@
+import { use3dModels as e } from "../../hooks/use3dModels.js";
+import { useAssetMappedNodesForRevisions as t } from "../../hooks/cad/useAssetMappedNodesForRevisions.js";
+import { useMappedEdgesForRevisions as n } from "../../hooks/cad/useMappedEdgesForRevisions.js";
+import "../../hooks/index.js";
+import { useAll3dDirectConnectionsWithProperties as r } from "../../query/useAll3dDirectConnectionsWithProperties.js";
+import "../../query/index.js";
+import { useFetchClassicAssetsByIds as i } from "../../query/useFetchClassicAssetsByIds.js";
+import { generateRuleBasedOutputs as a } from "./core/generateRuleBasedOutputs.js";
+import { useGetDMConnectionWithNodeFromHybridMappingsQuery as o } from "./hooks/useGetDMConnectionWithNodeFromHybridMappingsQuery.js";
+import { createContext as s } from "react";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/RuleBasedOutputsSelector.context.ts
+var c = {
+	use3dModels: e,
+	useAssetMappedNodesForRevisions: t,
+	useMappedEdgesForRevisions: n,
+	useAll3dDirectConnectionsWithProperties: r,
+	useGetDMConnectionWithNodeFromHybridMappingsQuery: o,
+	useFetchClassicAssetsByIds: i,
+	generateRuleBasedOutputs: a
+}, l = s(c);
+//#endregion
+export { l as RuleBasedOutputsSelectorContext, c as defaultRuleBasedOutputsSelectorDependencies };

package/dist/ui/components/RuleBasedOutputs/RuleBasedOutputsSelector.d.ts

@@ -0,0 +1,9 @@
+import { ReactElement } from 'react';
+import { StylingGroupAndStyleIndex, RuleOutputSet } from './types';
+export declare const ruleSetStylingCache: Map<string, StylingGroupAndStyleIndex[]>;
+export type ColorOverlayProps = {
+    ruleSet: RuleOutputSet | undefined;
+    onRuleSetChanged?: (currentStylings: StylingGroupAndStyleIndex[] | undefined) => void;
+    onAllMappingsFetched: (value: boolean) => void;
+};
+export declare function RuleBasedOutputsSelector({ ruleSet, onRuleSetChanged, onAllMappingsFetched, }: ColorOverlayProps): ReactElement | undefined;

package/dist/ui/components/RuleBasedOutputs/RuleBasedOutputsSelector.js

@@ -0,0 +1,80 @@
+import { isDmCadAssetMapping as e } from "../../../data-providers/cache/cad/assetMappingTypes.js";
+import { EMPTY_ARRAY as t } from "../../../utilities/constants.js";
+import { useCreateAssetMappingsMapPerModel as n } from "../../hooks/useCreateAssetMappingsMapPerModel.js";
+import { useAssetsAndTimeseriesLinkageDataQuery as r } from "../../query/useAssetsAndTimeseriesLinkageDataQuery.js";
+import { generateUniqueRuleSetKey as i } from "./core/generateUniqueRuleSetKey.js";
+import { hasInitializationDependenciesChanged as a } from "./core/hasInitializationDependenciesChanged.js";
+import { isReadyToInitializeRules as ee } from "./core/isReadyToInitializeRules.js";
+import { ruleBasedInitialization as o } from "./core/ruleBasedInitialization.js";
+import { useConvertAssetMetadatasToLowerCase as s } from "./hooks/useConvertAssetMetadatasToLowerCase.js";
+import { useExtractTimeseriesIdsFromRuleSet as c } from "./hooks/useExtractTimeseriesIdsFromRuleSet.js";
+import { useExtractUniqueClassicAssetIdsFromMapped as l } from "./hooks/useExtractUniqueClassicAssetIdsFromMapped.js";
+import { RuleBasedOutputsSelectorContext as u } from "./RuleBasedOutputsSelector.context.js";
+import { useContext as d, useMemo as f, useRef as p } from "react";
+import { Fragment as te, jsx as m } from "react/jsx-runtime";
+import { CogniteCadModel as h } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/RuleBasedOutputsSelector.tsx
+var g = /* @__PURE__ */ new Map();
+function _({ ruleSet: _, onRuleSetChanged: v, onAllMappingsFetched: y }) {
+	if (_ === void 0) return;
+	let { use3dModels: b, useAssetMappedNodesForRevisions: x, useMappedEdgesForRevisions: S, useAll3dDirectConnectionsWithProperties: C, useGetDMConnectionWithNodeFromHybridMappingsQuery: w, useFetchClassicAssetsByIds: T, generateRuleBasedOutputs: E } = d(u), D = b(), O = D.filter((e) => e instanceof h).map((e) => ({
+		type: "cad",
+		modelId: e.modelId,
+		revisionId: e.revisionId
+	})), { data: k, isInitialLoading: A } = x(O), j = l(k), { data: M, isInitialLoading: N } = T(j), P = f(() => {
+		if (M === void 0 || j.length === 0) return;
+		let e = new Set(j.map((e) => e.id));
+		return M.filter((t) => e.has(t.id));
+	}, [M, j]), F = f(() => k?.flatMap((t) => t.assetMappings.filter(e)), [k]), { data: I, isInitialLoading: L } = S(O, !0), { data: R } = w(F ?? t, O), z = f(() => I === void 0 ? [] : Array.from(I.values()).flat(), [I]), B = f(() => z.concat(R ?? []), [z, R]), { data: V, isInitialLoading: H } = C(B), U = !A && !N && !L && !H, W = s(P), G = c(_), { isInitialLoading: K, data: q } = r({
+		timeseriesExternalIds: G,
+		assetNodes: W
+	}), J = n(D, k), Y = p(void 0);
+	Y.current !== U && (Y.current = U, y(U));
+	let X = p(), Z = p(!1), Q = p(void 0), ne = ee({
+		ruleSet: _,
+		assetMappings: k,
+		fdmMappings: V,
+		timeseriesExternalIds: G,
+		isLoadingAssetIdsAndTimeseriesData: K,
+		allDataLoaded: U,
+		allClassicAssetConnections: P,
+		allFdmConnections: B,
+		models: D
+	}), $ = {
+		ruleSet: _,
+		assetMappings: k,
+		fdmMappings: V,
+		contextualizedClassicAssetNodes: W,
+		assetIdsWithTimeseriesData: q,
+		allDataLoaded: U,
+		allClassicAssetConnections: P,
+		allFdmConnections: B,
+		models: D,
+		timeseriesExternalIds: G,
+		isLoadingAssetIdsAndTimeseriesData: K,
+		flatAssetsMappingsListPerModel: J
+	}, re = a(X.current, $);
+	if (ne && re && !Z.current) {
+		let e = i(_, k, V, W, q, G);
+		X.current = $;
+		let t = g.get(e);
+		t === void 0 ? Q.current !== e && (Z.current = !0, Q.current = e, o({
+			models: D,
+			fdmMappings: V,
+			uniqueRuleSetKey: e,
+			contextualizedClassicAssetNodes: W,
+			assetIdsWithTimeseriesData: q,
+			initializationInProgressRef: Z,
+			flatAssetsMappingsListPerModel: J,
+			colorOverlay: {
+				ruleSet: _,
+				onAllMappingsFetched: y,
+				onRuleSetChanged: v
+			},
+			generateRuleBasedOutputs: E
+		})) : (v?.(t), y(!0), Q.current = e);
+	}
+	return /* @__PURE__ */ m(te, {});
+}
+//#endregion
+export { _ as RuleBasedOutputsSelector, g as ruleSetStylingCache };

package/dist/ui/components/RuleBasedOutputs/components/OutputPanelItem.d.ts

@@ -0,0 +1,8 @@
+import { ReactElement } from 'react';
+import { RuleOutput } from '../types';
+type OutputPanelItemProps = {
+    index: number;
+    output: RuleOutput;
+};
+export declare const OutputPanelItem: ({ index, output, }: OutputPanelItemProps) => ReactElement;
+export {};

package/dist/ui/components/RuleBasedOutputs/components/OutputPanelItem.js

@@ -0,0 +1,14 @@
+import { jsx as e, jsxs as t } from "react/jsx-runtime";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/components/OutputPanelItem.tsx
+var n = ({ index: n, output: r }) => /* @__PURE__ */ t("div", {
+	className: "flex w-full gap-2 items-center",
+	children: [/* @__PURE__ */ e("span", {
+		className: "h-[15px] w-[15px] rounded-full inline-block",
+		style: { background: r.type === "color" ? r.fill : "" }
+	}), /* @__PURE__ */ e("span", {
+		className: "leading-5",
+		children: r.label ?? (r.type === "color" ? r.fill : "")
+	})]
+}, n);
+//#endregion
+export { n as OutputPanelItem };

package/dist/ui/components/RuleBasedOutputs/components/OutputPanelShowMore.d.ts

@@ -0,0 +1,7 @@
+import { ReactElement } from 'react';
+type OutputPanelShowMoreProps = {
+    onShowMore: () => void;
+    isShowMore: boolean;
+};
+export declare const ShowMore: ({ onShowMore, isShowMore, }: OutputPanelShowMoreProps) => ReactElement;
+export {};

package/dist/ui/components/RuleBasedOutputs/components/OutputPanelShowMore.js

@@ -0,0 +1,20 @@
+import { useTranslation as e } from "../../i18n/I18n.js";
+import { jsx as t, jsxs as n } from "react/jsx-runtime";
+import { Button as r } from "@cognite/aura/components/button";
+import { IconMinus as i, IconPlus as a } from "@tabler/icons-react";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/components/OutputPanelShowMore.tsx
+var o = ({ onShowMore: o, isShowMore: s }) => {
+	let { t: c } = e();
+	return /* @__PURE__ */ t("div", {
+		className: "flex w-full gap-2 items-center justify-center",
+		style: { paddingBottom: s ? "10px" : void 0 },
+		children: /* @__PURE__ */ n(r, {
+			size: "sm",
+			variant: "ghost",
+			onClick: o,
+			children: [t(s ? i : a, { className: "size-4" }), c(s ? { key: "SHOW_LESS" } : { key: "SHOW_MORE" })]
+		})
+	}, "rule-based-panel-show-more");
+};
+//#endregion
+export { o as ShowMore };

package/dist/ui/components/RuleBasedOutputs/components/RuleBasedSelectionItem.d.ts

@@ -0,0 +1,12 @@
+import { ReactElement } from 'react';
+type RuleBasedSelectionItemProps = {
+    onChange: (value: string | undefined) => void;
+    label: string;
+    id: string;
+    checked: boolean | undefined;
+    key: string;
+    isLoading: boolean;
+    isEmptyRuleItem: boolean;
+};
+export declare const RuleBasedSelectionItem: ({ onChange, label, key, id, checked, isLoading, isEmptyRuleItem, }: RuleBasedSelectionItemProps) => ReactElement;
+export {};

package/dist/ui/components/RuleBasedOutputs/components/RuleBasedSelectionItem.js

@@ -0,0 +1,26 @@
+import { jsx as e, jsxs as t } from "react/jsx-runtime";
+import { IconPalette as n } from "@tabler/icons-react";
+import { CheckboxItemControl as r } from "@cognite/aura/components/checkbox";
+import { Loader as i } from "@cognite/aura/components/loader";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/components/RuleBasedSelectionItem.tsx
+var a = ({ onChange: a, label: o, key: s, id: c, checked: l, isLoading: u, isEmptyRuleItem: d }) => /* @__PURE__ */ t("div", {
+	role: "menuitemcheckbox",
+	"aria-checked": l ?? !1,
+	className: "flex items-center gap-2 px-2 py-1.5 cursor-pointer hover:bg-accent-background rounded-sm text-sm select-none",
+	onClick: () => {
+		a(c);
+	},
+	children: [
+		/* @__PURE__ */ e(r, { checked: l ?? !1 }),
+		/* @__PURE__ */ e("span", {
+			className: "flex-1",
+			children: o
+		}),
+		/* @__PURE__ */ t("div", {
+			className: "flex items-center gap-1 pr-1",
+			children: [!d && u && l === !0 && /* @__PURE__ */ e(i, {}), /* @__PURE__ */ e(n, { className: "size-4" })]
+		})
+	]
+}, s);
+//#endregion
+export { a as RuleBasedSelectionItem };

package/dist/ui/components/RuleBasedOutputs/constants.d.ts

@@ -0,0 +1,2 @@
+import { Source } from '../../../data-providers/FdmSDK';
+export declare const RULE_BASED_OUTPUTS_VIEW: Source;

package/dist/ui/components/RuleBasedOutputs/constants.js

@@ -0,0 +1,9 @@
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/constants.ts
+var e = {
+	type: "view",
+	version: "1",
+	externalId: "FdmRuleOutputSet",
+	space: "rule_based_outputs_space"
+};
+//#endregion
+export { e as RULE_BASED_OUTPUTS_VIEW };

package/dist/ui/components/RuleBasedOutputs/core/analyzeAssetMappingsAgainstExpression.d.ts

@@ -0,0 +1,12 @@
+import { Asset, Datapoints } from '@cognite/sdk';
+import { ClassicCadAssetMapping } from '../../../../data-providers/cache/cad/assetMappingTypes';
+import { AssetIdsAndTimeseries } from '../../../../data-providers/network/types';
+import { StylingGroupAndStyleIndex, ColorRuleOutput, Expression } from '../types';
+export declare const analyzeAssetMappingsAgainstExpression: ({ contextualizedAssetNodes, assetIdsAndTimeseries, timeseriesDatapoints, assetMappings, expression, outputSelected, }: {
+    contextualizedAssetNodes: Asset[];
+    assetIdsAndTimeseries: AssetIdsAndTimeseries[];
+    timeseriesDatapoints: Datapoints[] | undefined;
+    assetMappings: ClassicCadAssetMapping[];
+    expression: Expression;
+    outputSelected: ColorRuleOutput;
+}) => Promise<StylingGroupAndStyleIndex>;

package/dist/ui/components/RuleBasedOutputs/core/analyzeAssetMappingsAgainstExpression.js

@@ -0,0 +1,38 @@
+import { applyAssetMappingsNodeStyles as e } from "./applyAssetMappingsNodeStyles.js";
+import { generateTimeseriesAndDatapointsFromTheAsset as t } from "./generateTimeseriesAndDatapointsFromTheAsset.js";
+import { traverseExpression as n } from "./traverseExpression.js";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/core/analyzeAssetMappingsAgainstExpression.ts
+var r = async ({ contextualizedAssetNodes: r, assetIdsAndTimeseries: i, timeseriesDatapoints: a, assetMappings: o, expression: s, outputSelected: c }) => {
+	let l = [];
+	for (let e of r) {
+		let r = [], c = {
+			type: "metadata",
+			asset: e
+		};
+		if (r.push(c), a !== void 0 && a.length > 0 && i !== void 0 && i.length > 0) {
+			let n = t({
+				contextualizedAssetNode: e,
+				assetIdsAndTimeseries: i,
+				timeseriesDatapoints: a
+			});
+			if (n.length > 0) {
+				let t = {
+					type: "timeseries",
+					timeseries: {
+						timeseriesWithDatapoints: n,
+						linkedAssets: e
+					}
+				};
+				r.push(t);
+			}
+		}
+		if (n(r, [s])[0] ?? !1) {
+			let t = o.filter((t) => t.assetId === e.id);
+			l.push(t);
+		}
+	}
+	let u = l.flat();
+	return e(u, c);
+};
+//#endregion
+export { r as analyzeAssetMappingsAgainstExpression };

package/dist/ui/components/RuleBasedOutputs/core/analyzeFdmMappingsAgainstExpression.d.ts

@@ -0,0 +1,6 @@
+import { StylingGroupAndStyleIndex, ColorRuleOutput, Expression, FdmInstanceNodeWithConnectionAndProperties } from '../types';
+export declare const analyzeFdmMappingsAgainstExpression: ({ fdmMappings, expression, outputSelected, }: {
+    fdmMappings: FdmInstanceNodeWithConnectionAndProperties[];
+    expression: Expression;
+    outputSelected: ColorRuleOutput;
+}) => Promise<StylingGroupAndStyleIndex>;

package/dist/ui/components/RuleBasedOutputs/core/analyzeFdmMappingsAgainstExpression.js

@@ -0,0 +1,16 @@
+import { isDefined as e } from "../../../../utilities/isDefined.js";
+import { traverseExpression as t } from "./traverseExpression.js";
+import { applyFdmMappingsNodeStyles as n } from "./applyFdmMappingsNodeStyles.js";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/core/analyzeFdmMappingsAgainstExpression.ts
+var r = async ({ fdmMappings: r, expression: i, outputSelected: a }) => {
+	let o = (await Promise.all(r.map(async (e) => {
+		let n = [], r = {
+			type: "fdm",
+			instanceNode: e
+		};
+		if (n.push(r), t(n, [i])[0] ?? !1) return e;
+	}))).flat().filter(e);
+	return n(o, a);
+};
+//#endregion
+export { r as analyzeFdmMappingsAgainstExpression };

package/dist/ui/components/RuleBasedOutputs/core/applyAssetMappingsNodeStyles.d.ts

@@ -0,0 +1,3 @@
+import { ClassicCadAssetMapping } from '../../../../data-providers/cache/cad/assetMappingTypes';
+import { StylingGroupAndStyleIndex, ColorRuleOutput } from '../types';
+export declare const applyAssetMappingsNodeStyles: (treeNodes: ClassicCadAssetMapping[], outputSelected: ColorRuleOutput) => StylingGroupAndStyleIndex;

package/dist/ui/components/RuleBasedOutputs/core/applyAssetMappingsNodeStyles.js

@@ -0,0 +1,30 @@
+import { createRuleStyling as e } from "./createRuleStyling.js";
+import { Color as t } from "three";
+import { NumericRange as n, TreeIndexNodeCollection as r } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/core/applyAssetMappingsNodeStyles.ts
+var i = (i, a) => {
+	let o = {
+		styleIndex: new r(),
+		ruleOutputParams: a
+	}, s = o.styleIndex.getIndexSet();
+	s.clear();
+	let c = [];
+	for (let e of i) {
+		let t = new n(e.treeIndex, e.subtreeSize);
+		s.addRange(t), c.push(e.assetId);
+	}
+	o.styleIndex.updateSet(s);
+	let l = e({ color: new t(a.fill) }), u = {
+		instanceIds: c,
+		style: {
+			cad: l,
+			pointcloud: l
+		}
+	};
+	return {
+		styleIndex: o.styleIndex,
+		assetStylingGroup: u
+	};
+};
+//#endregion
+export { i as applyAssetMappingsNodeStyles };

package/dist/ui/components/RuleBasedOutputs/core/applyFdmMappingsNodeStyles.d.ts

@@ -0,0 +1,2 @@
+import { StylingGroupAndStyleIndex, ColorRuleOutput, FdmInstanceNodeWithConnectionAndProperties } from '../types';
+export declare const applyFdmMappingsNodeStyles: (treeNodes: FdmInstanceNodeWithConnectionAndProperties[], outputSelected: ColorRuleOutput) => StylingGroupAndStyleIndex;

package/dist/ui/components/RuleBasedOutputs/core/applyFdmMappingsNodeStyles.js

@@ -0,0 +1,33 @@
+import { createRuleStyling as e } from "./createRuleStyling.js";
+import { Color as t } from "three";
+import { NumericRange as n, TreeIndexNodeCollection as r } from "@cognite/reveal";
+//#region libs/shared/reveal-components/src/ui/components/RuleBasedOutputs/core/applyFdmMappingsNodeStyles.ts
+var i = (i, a) => {
+	let o = {
+		styleIndex: new r(),
+		ruleOutputParams: a
+	}, s = e({ color: new t(a.fill) }), c = [], l = o.styleIndex.getIndexSet();
+	l.clear();
+	for (let e of i) {
+		if (e.cadNode === void 0) continue;
+		let t = new n(e.cadNode.treeIndex, e.cadNode.subtreeSize);
+		l.addRange(t), e.connection !== void 0 && c.push({
+			space: e.connection?.instance.space,
+			externalId: e.connection?.instance.externalId
+		});
+	}
+	o.styleIndex.updateSet(l);
+	let u = {
+		instanceIds: c,
+		style: {
+			cad: s,
+			pointcloud: s
+		}
+	};
+	return {
+		styleIndex: o.styleIndex,
+		assetStylingGroup: u
+	};
+};
+//#endregion
+export { i as applyFdmMappingsNodeStyles };