@burdenoff/fluidgrids-fe-sdk 2026.1113.1 → 2026.1113.2

package/dist/config-X97zrIvn.js

@@ -0,0 +1,600 @@
+"use client";
+import { t as __exportAll } from "./rolldown-runtime-hDbaFkMy.js";
+import { create } from "zustand";
+
+// src/modules/executions/store/executionsStore.ts
+const DEFAULT_EXECUTIONS_FILTER = {
+	status: "all",
+	workflowKey: "",
+	dateRange: {
+		start: null,
+		end: null,
+		preset: "all"
+	},
+	search: "",
+	triggerType: "all",
+	durationMinSeconds: null,
+	durationMaxSeconds: null,
+	errorType: "all",
+	nodeId: "",
+	failedNodeType: "",
+	tagId: "",
+	workflowId: ""
+};
+const defaultPagination = {
+	page: 1,
+	pageSize: 25,
+	total: 0
+};
+const useExecutionsStore = create((set) => ({
+	viewMode: "table",
+	selectedExecution: null,
+	expandedRows: /* @__PURE__ */ new Set(),
+	selection: {
+		runIds: [],
+		allSelected: false
+	},
+	filter: DEFAULT_EXECUTIONS_FILTER,
+	pagination: defaultPagination,
+	isFilterPanelOpen: false,
+	isDetailsPanelOpen: false,
+	autoRefresh: true,
+	autoRefreshInterval: 5e3,
+	liveRunIds: /* @__PURE__ */ new Set(),
+	setViewMode: (mode) => set({ viewMode: mode }),
+	setSelectedExecution: (execution) => set({
+		selectedExecution: execution,
+		isDetailsPanelOpen: execution !== null
+	}),
+	toggleRowExpanded: (runId) => set((state) => {
+		const newExpanded = new Set(state.expandedRows);
+		if (newExpanded.has(runId)) newExpanded.delete(runId);
+		else newExpanded.add(runId);
+		return { expandedRows: newExpanded };
+	}),
+	setSelection: (selection) => set({ selection }),
+	toggleSelectRun: (runId) => set((state) => {
+		return { selection: {
+			runIds: state.selection.runIds.includes(runId) ? state.selection.runIds.filter((id) => id !== runId) : [...state.selection.runIds, runId],
+			allSelected: false
+		} };
+	}),
+	selectAll: (runIds) => set((state) => ({ selection: {
+		runIds: state.selection.allSelected ? [] : runIds,
+		allSelected: !state.selection.allSelected
+	} })),
+	clearSelection: () => set({ selection: {
+		runIds: [],
+		allSelected: false
+	} }),
+	updateFilter: (filterUpdate) => set((state) => ({
+		filter: {
+			...state.filter,
+			...filterUpdate
+		},
+		pagination: {
+			...state.pagination,
+			page: 1
+		}
+	})),
+	setStatusFilter: (status) => set((state) => ({
+		filter: {
+			...state.filter,
+			status
+		},
+		pagination: {
+			...state.pagination,
+			page: 1
+		}
+	})),
+	setWorkflowFilter: (workflowKey) => set((state) => ({
+		filter: {
+			...state.filter,
+			workflowKey
+		},
+		pagination: {
+			...state.pagination,
+			page: 1
+		}
+	})),
+	setDateRange: (dateRange) => set((state) => ({
+		filter: {
+			...state.filter,
+			dateRange
+		},
+		pagination: {
+			...state.pagination,
+			page: 1
+		}
+	})),
+	setSearchQuery: (search) => set((state) => ({
+		filter: {
+			...state.filter,
+			search
+		},
+		pagination: {
+			...state.pagination,
+			page: 1
+		}
+	})),
+	setTriggerTypeFilter: (triggerType) => set((state) => ({
+		filter: {
+			...state.filter,
+			triggerType
+		},
+		pagination: {
+			...state.pagination,
+			page: 1
+		}
+	})),
+	setDurationFilter: (durationMinSeconds, durationMaxSeconds) => set((state) => ({
+		filter: {
+			...state.filter,
+			durationMinSeconds,
+			durationMaxSeconds
+		},
+		pagination: {
+			...state.pagination,
+			page: 1
+		}
+	})),
+	setErrorTypeFilter: (errorType) => set((state) => ({
+		filter: {
+			...state.filter,
+			errorType
+		},
+		pagination: {
+			...state.pagination,
+			page: 1
+		}
+	})),
+	setNodeFilter: (nodeId) => set((state) => ({
+		filter: {
+			...state.filter,
+			nodeId
+		},
+		pagination: {
+			...state.pagination,
+			page: 1
+		}
+	})),
+	setFailedNodeTypeFilter: (failedNodeType) => set((state) => ({
+		filter: {
+			...state.filter,
+			failedNodeType
+		},
+		pagination: {
+			...state.pagination,
+			page: 1
+		}
+	})),
+	setTagFilter: (tagId) => set((state) => ({
+		filter: {
+			...state.filter,
+			tagId
+		},
+		pagination: {
+			...state.pagination,
+			page: 1
+		}
+	})),
+	setWorkflowIdFilter: (workflowId) => set((state) => ({
+		filter: {
+			...state.filter,
+			workflowId
+		},
+		pagination: {
+			...state.pagination,
+			page: 1
+		}
+	})),
+	resetFilters: () => set({
+		filter: DEFAULT_EXECUTIONS_FILTER,
+		pagination: { ...defaultPagination }
+	}),
+	setPage: (page) => set((state) => ({ pagination: {
+		...state.pagination,
+		page
+	} })),
+	setPageSize: (pageSize) => set((state) => ({ pagination: {
+		...state.pagination,
+		pageSize,
+		page: 1
+	} })),
+	setTotal: (total) => set((state) => ({ pagination: {
+		...state.pagination,
+		total
+	} })),
+	toggleFilterPanel: () => set((state) => ({ isFilterPanelOpen: !state.isFilterPanelOpen })),
+	toggleDetailsPanel: () => set((state) => ({ isDetailsPanelOpen: !state.isDetailsPanelOpen })),
+	setAutoRefresh: (enabled) => set({ autoRefresh: enabled }),
+	setAutoRefreshInterval: (interval) => set({ autoRefreshInterval: interval }),
+	addLiveRun: (runId) => set((state) => {
+		const newLiveRunIds = new Set(state.liveRunIds);
+		newLiveRunIds.add(runId);
+		return { liveRunIds: newLiveRunIds };
+	}),
+	removeLiveRun: (runId) => set((state) => {
+		const newLiveRunIds = new Set(state.liveRunIds);
+		newLiveRunIds.delete(runId);
+		return { liveRunIds: newLiveRunIds };
+	}),
+	clearLiveRuns: () => set({ liveRunIds: /* @__PURE__ */ new Set() })
+}));
+
+// src/theme/fluidgridsTheme.ts
+const color = (...cssVariables) => ({
+	kind: "color",
+	cssVariables
+});
+const length = (...cssVariables) => ({
+	kind: "length",
+	cssVariables
+});
+const font = (...cssVariables) => ({
+	kind: "font",
+	cssVariables
+});
+/**
+* Theme token → the fe-libs semantic CSS variables it sets. This table is the
+* public contract: a token keeps its variables across minor releases.
+*/
+const FLUIDGRIDS_THEME_TOKEN_MAP = {
+	"colors.bgCanvas": color("--color-bg-canvas"),
+	"colors.bgSurface": color("--color-bg-surface"),
+	"colors.bgElevated": color("--color-bg-elevated"),
+	"colors.bgSunken": color("--color-bg-sunken"),
+	"colors.textPrimary": color("--color-text-primary"),
+	"colors.textSecondary": color("--color-text-secondary"),
+	"colors.textMuted": color("--color-text-muted"),
+	"colors.borderDefault": color("--color-border-default"),
+	"colors.borderSubtle": color("--color-border-subtle"),
+	"colors.borderStrong": color("--color-border-strong"),
+	"colors.primary": color("--color-action-primary-bg", "--color-action-primary-border"),
+	"colors.primaryHover": color("--color-action-primary-bgHover"),
+	"colors.primaryActive": color("--color-action-primary-bgActive"),
+	"colors.primaryText": color("--color-action-primary-text"),
+	"colors.success": color("--color-status-success-bg"),
+	"colors.warning": color("--color-status-warning-bg"),
+	"colors.error": color("--color-status-error-bg"),
+	"colors.info": color("--color-status-info-bg"),
+	"radius.base": length("--radius"),
+	"radius.card": length("--radius-card"),
+	"radius.button": length("--radius-button"),
+	"radius.input": length("--radius-input"),
+	"font.body": font("--font-family-body", "--font-sans"),
+	"font.heading": font("--font-family-heading"),
+	"font.mono": font("--font-family-mono", "--font-mono")
+};
+const MAX_VALUE_LENGTH = 200;
+const FORBIDDEN_VALUE = /[;{}<>\\!@"`]|\/\*|\*\/|url\s*\(|expression\s*\(|image\s*\(|image-set\s*\(|javascript:|@import/i;
+const HEX_COLOR = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+const NAMED_COLOR = /^[a-z]{3,30}$/i;
+const COLOR_FUNCTION = /^(?:rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch|color|color-mix)\([a-z0-9#%.,/\s()+-]*\)$/i;
+const CSS_VAR = /^var\(--[a-z0-9-]+\)$/i;
+const LENGTH = /^(?:0|\d*\.?\d+(?:px|rem|em|%|vh|vw|vmin|vmax|ch|ex|pt))$/i;
+const CALC = /^calc\([a-z0-9%.\s()*/+-]*\)$/i;
+const FONT_FAMILY_ITEM = /^(?:[a-z0-9][a-z0-9 _-]*|'[a-z0-9 _-]+')$/i;
+function balancedParentheses(value) {
+	let depth = 0;
+	for (const char of value) {
+		if (char === "(") depth += 1;
+		if (char === ")") depth -= 1;
+		if (depth < 0) return false;
+	}
+	return depth === 0;
+}
+/**
+* Validate one token value. Returns the trimmed value, or null when it is not
+* a plain CSS value of the expected kind.
+*/
+function sanitizeThemeValue(kind, value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	if (!trimmed || trimmed.length > MAX_VALUE_LENGTH) return null;
+	if (FORBIDDEN_VALUE.test(trimmed) || !balancedParentheses(trimmed)) return null;
+	if (CSS_VAR.test(trimmed)) return trimmed;
+	switch (kind) {
+		case "color": return HEX_COLOR.test(trimmed) || NAMED_COLOR.test(trimmed) || COLOR_FUNCTION.test(trimmed) ? trimmed : null;
+		case "length": return LENGTH.test(trimmed) || CALC.test(trimmed) ? trimmed : null;
+		case "font": {
+			const items = trimmed.split(",").map((item) => item.trim());
+			return items.every((item) => FONT_FAMILY_ITEM.test(item)) ? items.join(", ") : null;
+		}
+	}
+}
+function warnDropped(key, value) {
+	console.warn(`[FluidGrids SDK] theme token "${key}" ignored: ${JSON.stringify(value)} is not a plain CSS value.`);
+}
+/** Relative luminance of a hex colour, or null for any other notation. */
+function hexLuminance(value) {
+	if (!HEX_COLOR.test(value)) return null;
+	let hex = value.slice(1);
+	if (hex.length <= 4) hex = hex.split("").map((digit) => digit + digit).join("");
+	const [red = 0, green = 0, blue = 0] = [
+		0,
+		2,
+		4
+	].map((offset) => {
+		const channel = parseInt(hex.slice(offset, offset + 2), 16) / 255;
+		return channel <= .03928 ? channel / 12.92 : Math.pow((channel + .055) / 1.055, 2.4);
+	});
+	return .2126 * red + .7152 * green + .0722 * blue;
+}
+/**
+* The resolved mode of a theme: the shortcut itself, `theme.mode`, or
+* undefined when the theme leaves the mode to the host.
+*/
+function themeMode(theme) {
+	if (theme === "light" || theme === "dark") return theme;
+	if (theme && typeof theme === "object") return theme.mode === "light" || theme.mode === "dark" ? theme.mode : void 0;
+}
+function groupEntries(theme, group) {
+	const values = theme[group];
+	if (!values || typeof values !== "object") return [];
+	return Object.entries(values);
+}
+function isTokenKey(key) {
+	return Object.prototype.hasOwnProperty.call(FLUIDGRIDS_THEME_TOKEN_MAP, key);
+}
+/**
+* Turn a theme into the CSS custom properties it sets. Pure: no DOM access.
+*
+* Values that are not plain CSS values of the token's kind (anything with
+* `;`, `{`, `}`, `url(`, `expression(`, quotes other than single-quoted font
+* names, …) are dropped with a console warning. Unknown keys are dropped the
+* same way. When `colors.primary` is set, the hover / pressed shades and the
+* text colour are derived from it unless they are set explicitly; the text
+* colour is picked for contrast when `primary` is a hex colour.
+*/
+function themeToCssVariables(theme) {
+	const variables = {};
+	if (!theme || typeof theme !== "object") return variables;
+	const colors = {};
+	for (const group of [
+		"colors",
+		"radius",
+		"font"
+	]) for (const [name, raw] of groupEntries(theme, group)) {
+		if (raw === void 0) continue;
+		const key = `${group}.${name}`;
+		if (!isTokenKey(key)) {
+			warnDropped(key, raw);
+			continue;
+		}
+		const mapping = FLUIDGRIDS_THEME_TOKEN_MAP[key];
+		const value = sanitizeThemeValue(mapping.kind, raw);
+		if (value === null) {
+			warnDropped(key, raw);
+			continue;
+		}
+		if (group === "colors") colors[name] = value;
+		for (const cssVariable of mapping.cssVariables) variables[cssVariable] = value;
+	}
+	const primary = colors.primary;
+	if (primary) {
+		if (!colors.primaryHover) variables["--color-action-primary-bgHover"] = `color-mix(in oklab, ${primary} 84%, var(--palette-black))`;
+		if (!colors.primaryActive) variables["--color-action-primary-bgActive"] = `color-mix(in oklab, ${primary} 70%, var(--palette-black))`;
+		if (!colors.primaryText) {
+			const luminance = hexLuminance(primary);
+			if (luminance !== null) variables["--color-action-primary-text"] = luminance > .4 ? "var(--palette-black)" : "var(--palette-white)";
+		}
+	}
+	return variables;
+}
+const stack = [];
+let nextId = 1;
+let observer = null;
+const hostVariables = /* @__PURE__ */ new Map();
+const appliedVariables = /* @__PURE__ */ new Map();
+let hostMode = null;
+function readHostMode(root) {
+	return {
+		dataTheme: root.getAttribute("data-theme"),
+		dark: root.classList.contains("dark")
+	};
+}
+function writeMode(root, mode) {
+	if (mode.dataTheme === null) root.removeAttribute("data-theme");
+	else if (root.getAttribute("data-theme") !== mode.dataTheme) root.setAttribute("data-theme", mode.dataTheme);
+	if (root.classList.contains("dark") !== mode.dark) root.classList.toggle("dark", mode.dark);
+}
+function modeDrifted(root, mode) {
+	return root.getAttribute("data-theme") !== mode || root.classList.contains("dark") !== (mode === "dark");
+}
+function restoreVariable(root, name) {
+	const previous = hostVariables.get(name) ?? "";
+	if (previous) root.style.setProperty(name, previous);
+	else root.style.removeProperty(name);
+	hostVariables.delete(name);
+	appliedVariables.delete(name);
+}
+function forceVariable(root, name, value) {
+	root.style.setProperty(name, value);
+	appliedVariables.set(name, root.style.getPropertyValue(name));
+}
+/** Re-force the winning theme where something else changed it. */
+function reconcileDrift() {
+	const top = stack.at(-1);
+	if (!top || typeof document === "undefined") return;
+	const root = document.documentElement;
+	for (const [name, value] of Object.entries(top.variables)) {
+		const current = root.style.getPropertyValue(name);
+		if (current !== appliedVariables.get(name)) {
+			hostVariables.set(name, current);
+			forceVariable(root, name, value);
+		}
+	}
+	if (top.mode && modeDrifted(root, top.mode)) {
+		hostMode = readHostMode(root);
+		writeMode(root, {
+			dataTheme: top.mode,
+			dark: top.mode === "dark"
+		});
+	}
+}
+/** Make the document match the top of the stack. */
+function sync() {
+	if (typeof document === "undefined") return;
+	const root = document.documentElement;
+	const top = stack.at(-1);
+	const wanted = top?.variables ?? {};
+	for (const name of [...appliedVariables.keys()]) if (!(name in wanted)) restoreVariable(root, name);
+	for (const [name, value] of Object.entries(wanted)) {
+		if (!hostVariables.has(name)) hostVariables.set(name, root.style.getPropertyValue(name));
+		if (appliedVariables.get(name) !== value) forceVariable(root, name, value);
+	}
+	if (top?.mode) {
+		if (!hostMode) hostMode = readHostMode(root);
+		writeMode(root, {
+			dataTheme: top.mode,
+			dark: top.mode === "dark"
+		});
+	} else if (hostMode) {
+		writeMode(root, hostMode);
+		hostMode = null;
+	}
+	if (!top) {
+		observer?.disconnect();
+		observer = null;
+		return;
+	}
+	if (!observer && typeof MutationObserver !== "undefined") {
+		observer = new MutationObserver(reconcileDrift);
+		observer.observe(root, {
+			attributes: true,
+			attributeFilter: [
+				"style",
+				"data-theme",
+				"class"
+			]
+		});
+	}
+}
+/**
+* Apply a theme to the document and return a function that removes it again.
+*
+* Sets each variable from {@link themeToCssVariables} as an inline custom
+* property on `document.documentElement`, and for a mode sets `data-theme`
+* and the `.dark` class. While applied, the values are re-forced if something
+* else (a host ThemeProvider) rewrites them. Disposing restores the inline
+* values and mode the document had (including any change the host made in
+* between). When several themes are applied, the most recent one wins.
+* Calling the returned function more than once is safe. Without a DOM
+* (server rendering) it does nothing.
+*/
+function applyFluidGridsTheme(theme) {
+	if (typeof document === "undefined") return () => void 0;
+	const entry = {
+		id: nextId++,
+		variables: themeToCssVariables(theme),
+		mode: themeMode(theme)
+	};
+	stack.push(entry);
+	sync();
+	let disposed = false;
+	return () => {
+		if (disposed) return;
+		disposed = true;
+		const index = stack.findIndex((active) => active.id === entry.id);
+		if (index >= 0) stack.splice(index, 1);
+		sync();
+	};
+}
+/**
+* Stable key for a theme value, so callers can tell two theme objects with the
+* same content apart from a real change (hosts often pass inline objects).
+*/
+function themeKey(theme) {
+	if (!theme) return "";
+	if (typeof theme === "string") return theme;
+	const sortedGroup = (group) => groupEntries(theme, group).filter(([, value]) => value !== void 0).sort(([a], [b]) => a.localeCompare(b));
+	return JSON.stringify([
+		theme.mode ?? null,
+		sortedGroup("colors"),
+		sortedGroup("radius"),
+		sortedGroup("font")
+	]);
+}
+
+// src/config/index.ts
+var config_exports = /* @__PURE__ */ __exportAll({ getFluidGridsConfig: () => getFluidGridsConfig });
+let runtimeConfig = {
+	apiGatewayUrl: "",
+	workspaceId: ""
+};
+/**
+* Get current configuration via proxy for live access
+*/
+const config = new Proxy({}, { get(_, prop) {
+	return runtimeConfig[prop];
+} });
+/**
+* Get the full configuration object
+*/
+function getFluidGridsConfig() {
+	return { ...runtimeConfig };
+}
+/**
+* Set runtime configuration
+*/
+function setFluidGridsConfig(newConfig) {
+	const previous = runtimeConfig;
+	runtimeConfig = {
+		...runtimeConfig,
+		...newConfig
+	};
+	if (previous.authToken !== runtimeConfig.authToken || previous.workspaceToken !== runtimeConfig.workspaceToken) tokenRevision += 1;
+	if ("theme" in newConfig) syncConfigTheme(newConfig.theme);
+}
+/**
+* Reset configuration to defaults
+*/
+function resetFluidGridsConfig() {
+	tokenRevision += 1;
+	runtimeConfig = {
+		apiGatewayUrl: "",
+		workspaceId: ""
+	};
+	syncConfigTheme(void 0);
+}
+let tokenRevision = 0;
+/** Current token revision. Internal: used by the SDK's Apollo clients. */
+function getFluidGridsTokenRevision() {
+	return tokenRevision;
+}
+let configTheme = null;
+function syncConfigTheme(theme) {
+	const key = themeKey(theme);
+	if (configTheme?.key === key) return;
+	const previous = configTheme;
+	configTheme = key ? {
+		key,
+		dispose: applyFluidGridsTheme(theme)
+	} : null;
+	previous?.dispose();
+}
+function normalizeOrigin(origin) {
+	return origin.replace(/\/$/, "");
+}
+function validateTrustedOrigin(trustedOrigins) {
+	if (typeof window === "undefined" || !trustedOrigins?.length) return;
+	const currentOrigin = normalizeOrigin(window.location.origin);
+	if (!trustedOrigins.map(normalizeOrigin).includes(currentOrigin)) throw new Error(`FluidGrids SDK blocked untrusted origin: ${currentOrigin}`);
+}
+/**
+* Get the GraphQL endpoint URL
+*/
+function getGraphQLEndpoint(baseUrl) {
+	const url = baseUrl || runtimeConfig.apiGatewayUrl;
+	if (!url) throw new Error("FluidGrids SDK requires apiGatewayUrl to be configured");
+	const normalizedBase = url.endsWith("/") ? url.slice(0, -1) : url;
+	if (normalizedBase.endsWith("/graphql")) return normalizedBase;
+	return `${normalizedBase}/workspaces/graphql`;
+}
+/** Clear user execution state only when a host session ends or changes identity. */
+function resetFluidGridsExecutionState() {
+	useExecutionsStore.setState(useExecutionsStore.getInitialState(), true);
+}
+
+export { getGraphQLEndpoint as a, setFluidGridsConfig as c, applyFluidGridsTheme as d, sanitizeThemeValue as f, useExecutionsStore as g, DEFAULT_EXECUTIONS_FILTER as h, getFluidGridsTokenRevision as i, validateTrustedOrigin as l, themeToCssVariables as m, config_exports as n, resetFluidGridsConfig as o, themeKey as p, getFluidGridsConfig as r, resetFluidGridsExecutionState as s, config as t, FLUIDGRIDS_THEME_TOKEN_MAP as u };

package/dist/{definition-canvas-Bshn_dSP.js → definition-canvas-DL25_6NH.js}

@@ -1,5 +1,5 @@
 "use client";
-import { F as mergeStickyNotes } from "./node-operation-selection-DAbS6jSY.js";
+import { r as mergeStickyNotes } from "./sticky-notes-23j-wL6Q.js";
 
 // src/builder/live/definition-canvas.ts
 function isRecord(value) {

package/dist/{dialog-Cjb4lB4D.js → dialog-BVd152GS.js}

@@ -1,22 +1,11 @@
 "use client";
-import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
 import { t as cn } from "./cn-QqidFIgr.js";
-import { forwardRef } from "react";
+import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
+import "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { XIcon } from "lucide-react";
 import * as DialogPrimitive from "@radix-ui/react-dialog";
 
-// src/ui/input.tsx
-const Input = forwardRef(({ className, type, ...props }, ref) => {
-	return /* @__PURE__ */ jsx("input", {
-		type,
-		className: cn("flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50", className),
-		ref,
-		...props
-	});
-});
-Input.displayName = "Input";
-
 // src/ui/dialog.tsx
 function Dialog({ ...props }) {
 	return /* @__PURE__ */ jsx(DialogPrimitive.Root, {
@@ -102,4 +91,4 @@ function DialogDescription({ className, ...props }) {
 	});
 }
 
-export { DialogFooter as a, DialogPortal as c, Input as d, DialogDescription as i, DialogTitle as l, DialogClose as n, DialogHeader as o, DialogContent as r, DialogOverlay as s, Dialog as t, DialogTrigger as u };
+export { DialogFooter as a, DialogPortal as c, DialogDescription as i, DialogTitle as l, DialogClose as n, DialogHeader as o, DialogContent as r, DialogOverlay as s, Dialog as t, DialogTrigger as u };