@datarecce/ui 0.1.41 → 0.2.1-nightly.20260402

package/dist/index-C9nBECPv.d.ts

@@ -0,0 +1,212 @@
+
+import { Ot as RunsAggregated, en as LineageDataFromMetadata, i as RecceServerFlags, tn as LineageDiffData } from "./instanceInfo-DNLFhkK8.js";
+import { c as LineageGraphNode, i as LineageGraph, l as LineageGraphNodes, o as LineageGraphContextType, r as EnvInfo, s as LineageGraphEdge, u as LineageViewContextType } from "./types-DLRfpcrV.js";
+import * as _$_tanstack_react_query0 from "@tanstack/react-query";
+import * as _$react from "react";
+import { ReactNode } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/contexts/lineage/utils.d.ts
+/**
+ * Height of a column node in pixels
+ * Must match COLUMN_NODE_HEIGHT in columns/LineageColumnNode.tsx
+ */
+declare const COLUMN_HEIGHT = 24;
+/**
+ * Map of node IDs to their column sets
+ */
+type NodeColumnSetMap = Record<string, Set<string>>;
+/**
+ * Get the union of multiple sets
+ */
+declare function union<T>(...sets: Set<T>[]): Set<T>;
+/**
+ * Get the intersection of multiple sets
+ */
+declare function intersect<T>(...sets: Set<T>[]): Set<T>;
+/**
+ * Get a set of neighbor nodes up to a certain degree
+ */
+declare function getNeighborSet(nodeIds: string[], getNeighbors: (id: string) => string[], degree?: number): Set<string>;
+/**
+ * Build a LineageGraph from base and current lineage data
+ *
+ * @param base - Base lineage data (before changes)
+ * @param current - Current lineage data (after changes)
+ * @param diff - Optional diff data for change status
+ * @returns Processed LineageGraph structure
+ *
+ * @example
+ * ```tsx
+ * const lineageGraph = buildLineageGraph(
+ *   serverInfo.lineage.base,
+ *   serverInfo.lineage.current,
+ *   serverInfo.lineage.diff
+ * );
+ * ```
+ */
+declare function buildLineageGraph(base: LineageDataFromMetadata, current: LineageDataFromMetadata, diff?: LineageDiffData): LineageGraph;
+/**
+ * Select upstream nodes from the given node IDs
+ *
+ * @param lineageGraph - The lineage graph
+ * @param nodeIds - Starting node IDs
+ * @param degree - Maximum degree of separation (default: 1000)
+ * @returns Set of upstream node IDs
+ */
+declare function selectUpstream(lineageGraph: LineageGraph, nodeIds: string[], degree?: number): Set<string>;
+/**
+ * Select downstream nodes from the given node IDs
+ *
+ * @param lineageGraph - The lineage graph
+ * @param nodeIds - Starting node IDs
+ * @param degree - Maximum degree of separation (default: 1000)
+ * @returns Set of downstream node IDs
+ */
+declare function selectDownstream(lineageGraph: LineageGraph, nodeIds: string[], degree?: number): Set<string>;
+/**
+ * Convert a LineageGraph to React Flow nodes and edges
+ *
+ * This is a simplified version that converts the graph structure.
+ * For full column-level lineage support, use the OSS implementation.
+ *
+ * @param lineageGraph - The lineage graph to convert
+ * @param selectedNodes - Optional filter for which nodes to include
+ * @returns Tuple of [nodes, edges]
+ */
+declare function toReactFlowBasic(lineageGraph: LineageGraph, selectedNodes?: string[]): [LineageGraphNode[], LineageGraphEdge[]];
+/**
+ * Apply dagre layout to nodes and edges
+ *
+ * NOTE: This function requires @dagrejs/dagre to be installed.
+ * Import and call it as follows:
+ *
+ * @example
+ * ```tsx
+ * import dagre from '@dagrejs/dagre';
+ * import { layoutWithDagre } from '@datarecce/ui';
+ *
+ * const [nodes, edges] = toReactFlowBasic(lineageGraph);
+ * layoutWithDagre(dagre, nodes, edges);
+ * ```
+ *
+ * @param dagre - The dagre library instance
+ * @param nodes - Nodes to layout
+ * @param edges - Edges for layout
+ * @param direction - Layout direction (default: "LR" for left-to-right)
+ */
+declare function layoutWithDagre(dagre: any, nodes: LineageGraphNodes[], edges: LineageGraphEdge[], direction?: string): void;
+//#endregion
+//#region src/contexts/lineage/LineageGraphContext.d.ts
+/**
+ * Props for LineageGraphProvider
+ *
+ * This is a props-driven provider - pass data from your data fetching layer.
+ * The provider does NOT fetch data internally; consumers handle data fetching
+ * and pass the results via props.
+ */
+interface LineageGraphProviderProps {
+  children: ReactNode;
+  /** The processed lineage graph data */
+  lineageGraph?: LineageGraph;
+  /** Environment information (git, dbt, sqlmesh metadata) */
+  envInfo?: EnvInfo;
+  /** Whether in review mode (read-only checks) */
+  reviewMode?: boolean;
+  /** Whether in cloud mode (recce cloud) */
+  cloudMode?: boolean;
+  /** Whether in file mode (loading from file) */
+  fileMode?: boolean;
+  /** The state file name if in file mode */
+  fileName?: string;
+  /** Whether this is the demo site */
+  isDemoSite?: boolean;
+  /** Whether running in GitHub Codespace */
+  isCodespace?: boolean;
+  /** Loading state */
+  isLoading?: boolean;
+  /** Error message if loading failed */
+  error?: string;
+  /** Supported task types from server */
+  supportTasks?: Record<string, boolean>;
+  /** Callback to refetch the lineage graph */
+  onRefetchLineageGraph?: () => void;
+  /** Pre-aggregated run results by model */
+  runsAggregated?: RunsAggregated;
+  /** Callback to refetch aggregated runs */
+  onRefetchRunsAggregated?: () => void;
+}
+/**
+ * Provider for LineageGraph context.
+ *
+ * This is a props-driven provider designed for library consumers.
+ * Pass data from your data fetching layer (e.g., TanStack Query).
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading, error, refetch } = useQuery({
+ *   queryKey: ['lineage'],
+ *   queryFn: fetchLineageData,
+ * });
+ *
+ * <LineageGraphProvider
+ *   lineageGraph={data?.lineageGraph}
+ *   envInfo={data?.envInfo}
+ *   isLoading={isLoading}
+ *   error={error?.message}
+ *   onRefetchLineageGraph={refetch}
+ * >
+ *   <LineageView />
+ * </LineageGraphProvider>
+ * ```
+ */
+declare function LineageGraphProvider({
+  children,
+  lineageGraph,
+  envInfo,
+  reviewMode,
+  cloudMode,
+  fileMode,
+  fileName,
+  isDemoSite,
+  isCodespace,
+  isLoading,
+  error,
+  supportTasks,
+  onRefetchLineageGraph,
+  runsAggregated,
+  onRefetchRunsAggregated
+}: LineageGraphProviderProps): _$react_jsx_runtime0.JSX.Element;
+/**
+ * Hook to access the LineageGraph context.
+ *
+ * @returns LineageGraphContextType with lineage data and utilities
+ * @throws Warning in dev mode if used outside provider (returns default context)
+ */
+declare function useLineageGraphContext(): LineageGraphContextType;
+/**
+ * Hook to access aggregated runs data.
+ * Convenience wrapper around useLineageGraphContext.
+ *
+ * @returns Tuple of [runsAggregated, refetchRunsAggregated]
+ */
+declare function useRunsAggregated(): [RunsAggregated | undefined, (() => void) | undefined];
+//#endregion
+//#region src/contexts/lineage/LineageViewContext.d.ts
+declare const LineageViewContext: _$react.Context<LineageViewContextType | undefined>;
+declare const useLineageViewContextSafe: () => LineageViewContextType;
+declare const useLineageViewContext: () => LineageViewContextType | undefined;
+//#endregion
+//#region src/contexts/lineage/useRecceServerFlag.d.ts
+/**
+ * Hook to fetch server-side feature flags.
+ *
+ * Uses TanStack Query to cache and manage flag state.
+ * Works both inside RecceProvider (uses configured client) and outside (uses default API client).
+ *
+ * @returns TanStack Query result with RecceServerFlags data
+ */
+declare function useRecceServerFlag(): _$_tanstack_react_query0.UseQueryResult<RecceServerFlags, Error>;
+//#endregion
+export { toReactFlowBasic as _, LineageGraphProvider as a, useRunsAggregated as c, buildLineageGraph as d, getNeighborSet as f, selectUpstream as g, selectDownstream as h, useLineageViewContextSafe as i, COLUMN_HEIGHT as l, layoutWithDagre as m, LineageViewContext as n, LineageGraphProviderProps as o, intersect as p, useLineageViewContext as r, useLineageGraphContext as s, useRecceServerFlag as t, NodeColumnSetMap as u, union as v };
+//# sourceMappingURL=index-C9nBECPv.d.ts.map

package/dist/index-C9nBECPv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-C9nBECPv.d.ts","names":[],"sources":["../src/contexts/lineage/utils.ts","../src/contexts/lineage/LineageGraphContext.tsx","../src/contexts/lineage/LineageViewContext.tsx","../src/contexts/lineage/useRecceServerFlag.ts"],"mappings":";;;;;;;;;;;;;cAea,aAAA;;AAAb;;KAKY,gBAAA,GAAmB,MAAA,SAAe,GAAA;;;AAA9C;iBASgB,KAAA,GAAA,CAAA,GAAY,IAAA,EAAM,GAAA,CAAI,CAAA,MAAO,GAAA,CAAI,CAAA;;;;iBAajC,SAAA,GAAA,CAAA,GAAgB,IAAA,EAAM,GAAA,CAAI,CAAA,MAAO,GAAA,CAAI,CAAA;;;;iBAiBrC,cAAA,CACd,OAAA,YACA,YAAA,GAAe,EAAA,uBACf,MAAA,YACC,GAAA;;;;;;;;;;;;;AArBH;;;;;iBAuEgB,iBAAA,CACd,IAAA,EAAM,uBAAA,EACN,OAAA,EAAS,uBAAA,EACT,IAAA,GAAO,eAAA,GACN,YAAA;;;;;;;;;iBA+Ka,cAAA,CACd,YAAA,EAAc,YAAA,EACd,OAAA,YACA,MAAA,YACC,GAAA;;;AA7OH;;;;;;iBAsQgB,gBAAA,CACd,YAAA,EAAc,YAAA,EACd,OAAA,YACA,MAAA,YACC,GAAA;;;;;AApNH;;;;;;iBAiPgB,gBAAA,CACd,YAAA,EAAc,YAAA,EACd,aAAA,eACE,gBAAA,IAAoB,gBAAA;;;;;;;;;;;;AAjExB;;;;;;;;;iBA8JgB,eAAA,CAEd,KAAA,OACA,KAAA,EAAO,iBAAA,IACP,KAAA,EAAO,gBAAA,IACP,SAAA;;;;;;;;AAxbF;;UCIiB,yBAAA;EACf,QAAA,EAAU,SAAA;EDLc;ECQxB,YAAA,GAAe,YAAA;EDHW;ECM1B,OAAA,GAAU,OAAA;EDNmB;ECS7B,UAAA;EDAc;ECGd,SAAA;EDHmB;ECMnB,QAAA;EDNgC;ECShC,QAAA;EDT2C;ECY3C,UAAA;EDZ8C;ECe9C,WAAA;EDf0B;ECkB1B,SAAA;EDlBoC;ECqBpC,KAAA;EDrB+C;ECwB/C,YAAA,GAAe,MAAA;EDxBiC;EC2BhD,qBAAA;EDduB;ECiBvB,cAAA,GAAiB,cAAA;EDjBuB;ECoBxC,uBAAA;AAAA;;;;;;;;;;;;ADHF;;;;;;;;;;;AAsDA;;iBCdgB,oBAAA,CAAA;EACd,QAAA;EACA,YAAA;EACA,OAAA;EACA,UAAA;EACA,SAAA;EACA,QAAA;EACA,QAAA;EACA,UAAA;EACA,WAAA;EACA,SAAA;EACA,KAAA;EACA,YAAA;EACA,qBAAA;EACA,cAAA;EACA;AAAA,GACC,yBAAA,GAAyB,oBAAA,CAAA,GAAA,CAAA,OAAA;;;;;;;iBAiEZ,sBAAA,CAAA,GAA0B,uBAAA;;;;;;;iBAW1B,iBAAA,CAAA,IACd,cAAA;;;cC7LW,kBAAA,EAAkB,OAAA,CAAA,OAAA,CAAA,sBAAA;AAAA,cAIlB,yBAAA,QAAgC,sBAAA;AAAA,cAUhC,qBAAA,QAA4B,sBAAA;;;;;;;;;;AFFzC;iBGIgB,kBAAA,CAAA,GAAkB,wBAAA,CAAA,cAAA,CAAA,gBAAA,EAAA,KAAA"}

package/dist/index-CHJ0PCEg.d.ts

@@ -0,0 +1,380 @@
+
+import { Theme } from "@mui/material/styles";
+import * as _$ag_grid_community0 from "ag-grid-community";
+import * as _$_mui_material0 from "@mui/material";
+
+//#region src/components/data/agGridTheme.d.ts
+/**
+ * Light theme for AG Grid data grids
+ */
+declare const dataGridThemeLight: _$ag_grid_community0.Theme<_$ag_grid_community0.ThemeDefaultParams>;
+/**
+ * Dark theme for AG Grid data grids
+ */
+declare const dataGridThemeDark: _$ag_grid_community0.Theme<_$ag_grid_community0.ThemeDefaultParams>;
+//#endregion
+//#region src/theme/chartTheme.d.ts
+/**
+ * Shared Chart.js theme utilities for dark mode support
+ */
+interface ChartThemeColors {
+  gridColor: string;
+  textColor: string;
+  borderColor: string;
+  tooltipBackgroundColor: string;
+  tooltipTextColor: string;
+}
+/**
+ * Get theme-aware colors for Chart.js charts
+ * @param isDark - Whether dark mode is active
+ * @returns Theme colors for Chart.js configuration
+ */
+declare function getChartThemeColors(isDark: boolean): ChartThemeColors;
+/**
+ * Get Chart.js scale options with theme-aware colors
+ * @param isDark - Whether dark mode is active
+ * @param showGrid - Whether to show grid lines
+ * @returns Partial scale options for Chart.js
+ */
+declare function getThemedScaleOptions(isDark: boolean, showGrid?: boolean): {
+  grid: {
+    color: string | undefined;
+    display: boolean;
+  };
+  ticks: {
+    color: string;
+  };
+  border: {
+    color: string;
+  };
+};
+/**
+ * Get Chart.js plugin options with theme-aware colors
+ * @param isDark - Whether dark mode is active
+ * @returns Plugin options for Chart.js (legend, title, tooltip)
+ */
+declare function getThemedPluginOptions(isDark: boolean): {
+  legend: {
+    labels: {
+      color: string;
+    };
+  };
+  title: {
+    color: string;
+  };
+  tooltip: {
+    backgroundColor: string;
+    titleColor: string;
+    bodyColor: string;
+    borderColor: string;
+    borderWidth: number;
+  };
+};
+declare const CURRENT_BAR_COLOR = "#63B3ED";
+declare const BASE_BAR_COLOR = "#F6AD55";
+declare const CURRENT_BAR_COLOR_WITH_ALPHA = "#63B3EDA5";
+declare const BASE_BAR_COLOR_WITH_ALPHA = "#F6AD55A5";
+declare const CURRENT_BAR_COLOR_DARK = "#90CDF4";
+declare const BASE_BAR_COLOR_DARK = "#FBD38D";
+declare const CURRENT_BAR_COLOR_DARK_WITH_ALPHA = "#90CDF4A5";
+declare const BASE_BAR_COLOR_DARK_WITH_ALPHA = "#FBD38DA5";
+declare const INFO_VAL_COLOR = "#63B3ED";
+declare const INFO_VAL_COLOR_DARK = "#90CDF4";
+/**
+ * Get theme-aware bar colors for charts
+ * @param isDark - Whether dark mode is active
+ * @returns Object with current and base bar colors
+ */
+declare function getBarColors(isDark: boolean): {
+  current: string;
+  base: string;
+  currentWithAlpha: string;
+  baseWithAlpha: string;
+  info: string;
+};
+//#endregion
+//#region src/theme/colors.d.ts
+/**
+ * Recce brand colors and palette definitions
+ *
+ * These colors are used to create a consistent visual identity across
+ * the Recce UI components. The palette includes brand colors, semantic
+ * colors for status indicators, and neutral grays.
+ *
+ * Color values are aligned with the main Recce theme at
+ * ui/src/components/ui/mui-theme.ts for consistency.
+ */
+declare const colors: {
+  /** White color */readonly white: "#FFFFFF"; /** Black color */
+  readonly black: "#000000";
+  /**
+   * Primary brand color - Orange/Coral
+   * Used for primary actions, branding elements, and highlights
+   */
+  readonly brand: {
+    readonly 50: "#FFDED5";
+    readonly 100: "#FFC1B0";
+    readonly 200: "#FFA58C";
+    readonly 300: "#FF8967";
+    readonly 400: "#FF6E42";
+    readonly 500: "#FD541E";
+    readonly 600: "#F04104";
+    readonly 700: "#C93A06";
+    readonly 800: "#A23206";
+    readonly 900: "#7C2906";
+    readonly 950: "#571E05";
+  };
+  /**
+   * Secondary color - Blue (Iochmara)
+   * Used for secondary actions, links, and information elements
+   */
+  readonly iochmara: {
+    readonly 50: "#EAF3FB";
+    readonly 100: "#C4DDF3";
+    readonly 200: "#9EC6EB";
+    readonly 300: "#79B0E2";
+    readonly 400: "#5599D8";
+    readonly 500: "#3182CE";
+    readonly 600: "#2A6CA7";
+    readonly 700: "#225581";
+    readonly 800: "#193E5C";
+    readonly 900: "#102638";
+    readonly 950: "#060E14";
+  };
+  /**
+   * Neutral grays
+   * Used for backgrounds, borders, and text
+   */
+  readonly neutral: {
+    readonly 50: "#FAFAFA";
+    readonly 100: "#F5F5F5";
+    readonly 200: "#E5E5E5";
+    readonly 300: "#D4D4D4";
+    readonly 400: "#A3A3A3";
+    readonly 500: "#737373";
+    readonly 600: "#525252";
+    readonly 700: "#404040";
+    readonly 800: "#262626";
+    readonly 900: "#171717";
+    readonly 950: "#0A0A0A";
+  };
+  /**
+   * Cyan color scale
+   * Used for secondary accents
+   */
+  readonly cyan: {
+    readonly 50: "#ECFEFF";
+    readonly 100: "#CFFAFE";
+    readonly 200: "#A5F3FC";
+    readonly 300: "#67E8F9";
+    readonly 400: "#22D3EE";
+    readonly 500: "#06B6D4";
+    readonly 600: "#0891B2";
+    readonly 700: "#0E7490";
+    readonly 800: "#155E75";
+    readonly 900: "#164E63";
+    readonly 950: "#083344";
+  };
+  /**
+   * Amber color scale
+   * Used for warnings
+   */
+  readonly amber: {
+    readonly 50: "#FFFBEB";
+    readonly 100: "#FEF3C7";
+    readonly 200: "#FDE68A";
+    readonly 300: "#FCD34D";
+    readonly 400: "#FBBF24";
+    readonly 500: "#F59E0B";
+    readonly 600: "#D97706";
+    readonly 700: "#B45309";
+    readonly 800: "#92400E";
+    readonly 900: "#78350F";
+    readonly 950: "#431407";
+  };
+  /**
+   * Yellow color scale
+   * Used for warnings and highlights
+   */
+  readonly yellow: {
+    readonly 50: "#FEFCE8";
+    readonly 100: "#FEF9C3";
+    readonly 200: "#FEF08A";
+    readonly 300: "#FDE047";
+    readonly 400: "#FACC15";
+    readonly 500: "#EAB308";
+    readonly 600: "#CA8A04";
+    readonly 700: "#A16207";
+    readonly 800: "#854D0E";
+    readonly 900: "#713F12";
+    readonly 950: "#422006";
+  };
+  /**
+   * Green color scale
+   * Used for success states
+   */
+  readonly green: {
+    readonly 50: "#F0FDF4";
+    readonly 100: "#DCFCE7";
+    readonly 200: "#BBF7D0";
+    readonly 300: "#86EFAC";
+    readonly 400: "#4ADE80";
+    readonly 500: "#22C55E";
+    readonly 600: "#16A34A";
+    readonly 700: "#15803D";
+    readonly 800: "#166534";
+    readonly 900: "#14532D";
+    readonly 950: "#052E16";
+  };
+  /**
+   * Red color scale
+   * Used for errors
+   */
+  readonly red: {
+    readonly 50: "#FEF2F2";
+    readonly 100: "#FEE2E2";
+    readonly 200: "#FECACA";
+    readonly 300: "#FCA5A5";
+    readonly 400: "#F87171";
+    readonly 500: "#EF4444";
+    readonly 600: "#DC2626";
+    readonly 700: "#B91C1C";
+    readonly 800: "#991B1B";
+    readonly 900: "#7F1D1D";
+    readonly 950: "#450A0A";
+  };
+  /**
+   * Rose color scale
+   * Used for accent colors
+   */
+  readonly rose: {
+    readonly 50: "#FFF1F2";
+    readonly 100: "#FFE4E6";
+    readonly 200: "#FECDD3";
+    readonly 300: "#FDA4AF";
+    readonly 400: "#FB7185";
+    readonly 500: "#F43F5E";
+    readonly 600: "#E11D48";
+    readonly 700: "#BE123C";
+    readonly 800: "#9F1239";
+    readonly 900: "#881337";
+    readonly 950: "#4C0519";
+  };
+  /**
+   * Fuchsia color scale
+   * Used for accent colors
+   */
+  readonly fuchsia: {
+    readonly 50: "#FDF4FF";
+    readonly 100: "#FAE8FF";
+    readonly 200: "#F5D0FE";
+    readonly 300: "#F0ABFC";
+    readonly 400: "#E879F9";
+    readonly 500: "#D946EF";
+    readonly 600: "#C026D3";
+    readonly 700: "#A21CAF";
+    readonly 800: "#86198F";
+    readonly 900: "#701A75";
+    readonly 950: "#4A044E";
+  };
+  /**
+   * Semantic colors for status indicators
+   */
+  readonly success: {
+    readonly main: "#22C55E";
+    readonly light: "#4ADE80";
+    readonly dark: "#16A34A";
+    readonly contrastText: "#ffffff";
+  };
+  readonly warning: {
+    readonly main: "#EAB308";
+    readonly light: "#FACC15";
+    readonly dark: "#78350F";
+    readonly contrastText: "#000000";
+  };
+  readonly error: {
+    readonly main: "#EF4444";
+    readonly light: "#F87171";
+    readonly dark: "#DC2626";
+    readonly contrastText: "#ffffff";
+  };
+  readonly info: {
+    readonly main: "#3182CE";
+    readonly light: "#79B0E2";
+    readonly dark: "#225581";
+    readonly contrastText: "#ffffff";
+  };
+};
+/**
+ * Color aliases for backward compatibility
+ * Maps common color names to their Recce palette equivalents
+ */
+declare const colorAliases: Record<string, keyof typeof colors>;
+/**
+ * Type for accessing color shades
+ */
+type ColorShade = 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | 950;
+/**
+ * Type for semantic color variants
+ */
+type SemanticColorVariant = "light" | "main" | "dark" | "contrastText";
+/**
+ * Semantic variant mappings from Chakra-style tokens to scale values
+ * These map semantic names to numeric scale values in the color palette
+ *
+ * Used during Chakra UI -> MUI migration to translate Chakra token paths
+ * like "colors.green.solid" to actual color values
+ */
+declare const semanticVariantMap: Record<string, number>;
+/**
+ * Token lookup function to mimic Chakra UI's token API
+ *
+ * This utility function translates Chakra-style token paths to actual
+ * color values from the color palette. Used during migration from
+ * Chakra UI to MUI.
+ *
+ * @param path - Token path like "colors.green.solid" or "colors.neutral.500"
+ * @returns The hex color value, or undefined if not found
+ *
+ * @example
+ * token("colors.green.solid") // => "#16A34A"
+ * token("colors.neutral.500") // => "#737373"
+ * token("colors.orange.400")  // => "#FBBF24" (maps orange to amber)
+ */
+declare function token(path: string): string | undefined;
+//#endregion
+//#region src/theme/theme.d.ts
+/**
+ * MUI Theme configuration with CSS Variables mode
+ *
+ * This theme uses MUI 7's CSS Variables mode with `colorSchemeSelector: 'class'`
+ * to toggle between light and dark modes using the `.dark` class on the document.
+ * This integrates with the ThemeContext which manages the class toggle.
+ *
+ * Color values and component variants are aligned with the main Recce theme at
+ * ui/src/components/ui/mui-theme.ts for consistency.
+ */
+/**
+ * MUI Theme with CSS Variables mode enabled
+ *
+ * Uses `colorSchemeSelector: 'class'` to switch themes via `.dark` class,
+ * which is toggled by the ThemeContext provider.
+ *
+ * Usage:
+ * ```tsx
+ * import { ThemeProvider } from '@mui/material/styles';
+ * import { theme } from '@datarecce/ui/theme';
+ *
+ * <ThemeProvider theme={theme}>
+ *   <App />
+ * </ThemeProvider>
+ * ```
+ */
+declare const theme: _$_mui_material0.Theme;
+/**
+ * Theme type export for consumers who need to type their theme
+ */
+type RecceTheme = typeof theme;
+//#endregion
+export { getThemedPluginOptions as C, dataGridThemeLight as E, getChartThemeColors as S, dataGridThemeDark as T, CURRENT_BAR_COLOR_WITH_ALPHA as _, SemanticColorVariant as a, INFO_VAL_COLOR_DARK as b, semanticVariantMap as c, BASE_BAR_COLOR_DARK as d, BASE_BAR_COLOR_DARK_WITH_ALPHA as f, CURRENT_BAR_COLOR_DARK_WITH_ALPHA as g, CURRENT_BAR_COLOR_DARK as h, ColorShade as i, token as l, CURRENT_BAR_COLOR as m, RecceTheme as n, colorAliases as o, BASE_BAR_COLOR_WITH_ALPHA as p, theme as r, colors as s, Theme as t, BASE_BAR_COLOR as u, ChartThemeColors as v, getThemedScaleOptions as w, getBarColors as x, INFO_VAL_COLOR as y };
+//# sourceMappingURL=index-CHJ0PCEg.d.ts.map

package/dist/index-CHJ0PCEg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CHJ0PCEg.d.ts","names":[],"sources":["../src/components/data/agGridTheme.ts","../src/theme/chartTheme.ts","../src/theme/colors.ts","../src/theme/theme.ts"],"mappings":";;;;;;;;;cAkBa,kBAAA,EAAkB,oBAAA,CAAA,KAAA,CAa7B,oBAAA,CAb6B,kBAAA;;AAA/B;;cAkBa,iBAAA,EAAiB,oBAAA,CAAA,KAAA,CAa5B,oBAAA,CAb4B,kBAAA;;;;;;UChCb,gBAAA;EACf,SAAA;EACA,SAAA;EACA,WAAA;EACA,sBAAA;EACA,gBAAA;AAAA;AD2BF;;;;;AAAA,iBCnBgB,mBAAA,CAAoB,MAAA,YAAkB,gBAAA;;;AAbtD;;;;iBA6BgB,qBAAA,CAAsB,MAAA,WAAiB,QAAA;;;;;;;;;;;;AAAvD;;;;;AAAA,iBAqBgB,sBAAA,CAAuB,MAAA;;;;;;;;;;;;;;;;;cAsB1B,iBAAA;AAAA,cACA,cAAA;AAAA,cACA,4BAAA;AAAA,cACA,yBAAA;AAAA,cAGA,sBAAA;AAAA,cACA,mBAAA;AAAA,cACA,iCAAA;AAAA,cACA,8BAAA;AAAA,cAGA,cAAA;AAAA,cACA,mBAAA;;AAbb;;;;iBAoBgB,YAAA,CAAa,MAAA;;;;;;;;;;;;;;AD9E7B;;;;;cEPa,MAAA;EFsCX,6CAb4B;EAAA;;;;AChC9B;;;;;;;;;;;;;;EAaoC;;AAgBpC;;EAhBoC;;;;;;;;;;;;;EAqCpB;;;;EAAA;;;;;;;;;;;;;;AAsBhB;;;;;;;;;;;;;;;;EAGsC;;;;EAAA;;;;;;;;;;;;;EAKQ;;AAC9C;;EAD8C;;;;;;;;;;;;;EAY9B;;;;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCyIH,YAAA,EAAc,MAAA,sBAA4B,MAAA;;;;KAQ3C,UAAA;;;;KAgBA,oBAAA;;;;;;;;cASC,kBAAA,EAAoB,MAAA;;;;;;;;;;;;;;;;iBAwBjB,KAAA,CAAM,IAAA;;;;;;;;AFhRtB;;;;;AAkBA;;;;;;;;AChCA;;;;;;;;ADgCA,cGkmBa,KAAA,EAuMX,gBAAA,CAvMgB,KAAA;;;AFrnBlB;KEi0BY,UAAA,UAAoB,KAAA"}

package/dist/index-CZ7gueQV.d.ts

@@ -0,0 +1,13 @@
+
+//#region src/constants/tooltipMessage.d.ts
+/**
+ * Tooltip messages for disabled UI elements.
+ * Used across lineage and check components to explain why actions are unavailable.
+ */
+declare const DisableTooltipMessages: {
+  readonly add_or_remove: "Unavailable for added or removed resources.";
+};
+type DisableTooltipMessageKey = keyof typeof DisableTooltipMessages;
+//#endregion
+export { DisableTooltipMessages as n, DisableTooltipMessageKey as t };
+//# sourceMappingURL=index-CZ7gueQV.d.ts.map

package/dist/index-CZ7gueQV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CZ7gueQV.d.ts","names":[],"sources":["../src/constants/tooltipMessage.ts"],"mappings":";;;AAIA;;;cAAa,sBAAA;EAAA,SAEH,aAAA;AAAA;AAAA,KAEE,wBAAA,gBAAwC,sBAAA"}