@datarecce/ui 0.1.40 → 0.2.0

package/dist/index-DVoQsx5c.d.ts

@@ -0,0 +1,349 @@
+
+import { i as RecceInstanceInfo } from "./flag-CiR2E5oz.js";
+import * as _tanstack_react_query5 from "@tanstack/react-query";
+import { Dispatch, ReactNode, SetStateAction } from "react";
+import * as react_jsx_runtime130 from "react/jsx-runtime";
+
+//#region src/contexts/action/types.d.ts
+/**
+ * Query parameters for API requests
+ */
+type AxiosQueryParams = Record<string, string | string[] | number | number[] | undefined>;
+/**
+ * Explore action sources - matches EXPLORE_SOURCE in track.ts
+ */
+type ExploreSource = "lineage_view_top_bar" | "lineage_view_context_menu" | "node_kebab_menu" | "node_sidebar_single_env" | "node_sidebar_multi_env" | "schema_row_count_button" | "schema_column_menu" | "lineage_model_node" | "lineage_column_node";
+/**
+ * Explore action types - matches EXPLORE_ACTION in track.ts
+ */
+type ExploreAction = "row_count" | "row_count_diff" | "profile" | "profile_diff" | "value_diff" | "schema_diff" | "lineage_diff" | "query" | "histogram_diff" | "top_k_diff";
+/**
+ * Tracking properties for run submissions
+ */
+interface SubmitRunTrackProps {
+  /** The explore action type being performed */
+  action?: ExploreAction;
+  /** The source UI element triggering the action */
+  source?: ExploreSource;
+  /** Number of nodes involved in the action */
+  node_count?: number;
+  /** Whether breaking change analysis is enabled */
+  breaking_change_analysis?: boolean;
+  /** Additional tracking properties */
+  [key: string]: unknown;
+}
+/**
+ * Options for running an action
+ */
+interface RecceActionOptions {
+  /** Whether to show a form before executing */
+  showForm: boolean;
+  /** Whether to show the last run with matching params */
+  showLast?: boolean;
+  /** Tracking properties for analytics */
+  trackProps?: SubmitRunTrackProps;
+}
+/**
+ * Context type for run actions.
+ *
+ * This context manages run execution, run result display,
+ * and history panel state.
+ */
+interface RecceActionContextType {
+  /**
+   * Execute a run action.
+   * @param type - The run type (e.g., "row_count_diff", "value_diff")
+   * @param params - Query parameters for the run
+   * @param actionOptions - Action options (showForm, trackProps)
+   */
+  runAction: (type: string, params?: AxiosQueryParams, actionOptions?: RecceActionOptions) => void;
+  /** Currently displayed run ID */
+  runId?: string;
+  /**
+   * Show a specific run result.
+   * @param runId - The run ID to display
+   * @param refreshHistory - Whether to refresh the history list
+   */
+  showRunId: (runId: string, refreshHistory?: boolean) => void;
+  /** Whether the run result pane is open */
+  isRunResultOpen: boolean;
+  /** Close the run result pane */
+  closeRunResult: () => void;
+  /** Whether the history panel is open */
+  isHistoryOpen: boolean;
+  /** Close the history panel */
+  closeHistory: () => void;
+  /** Open the history panel */
+  showHistory: () => void;
+  /** Set the history panel open state */
+  setHistoryOpen: Dispatch<SetStateAction<boolean>>;
+  /** Clear the current run result and close the pane */
+  clearRunResult: () => void;
+}
+//#endregion
+//#region src/contexts/action/RecceActionContext.d.ts
+/**
+ * Props for RecceActionProvider
+ *
+ * This is a props-driven provider - pass your own run execution handler.
+ * The provider manages UI state (result pane, history panel) internally.
+ */
+interface RecceActionProviderProps {
+  children: ReactNode;
+  /**
+   * Handler called when a run action is requested.
+   * Implement this to submit runs to your backend.
+   *
+   * @param type - The run type (e.g., "row_count_diff", "value_diff")
+   * @param params - Query parameters for the run
+   * @param options - Action options (showForm, trackProps)
+   * @returns Promise that resolves to the run ID, or void if handled differently
+   */
+  onRunAction?: (type: string, params?: AxiosQueryParams, options?: RecceActionOptions) => Promise<string | undefined> | string | undefined;
+  /**
+   * Handler called when a run result should be shown.
+   * Called by showRunId when displaying a specific run.
+   *
+   * @param runId - The run ID to display
+   * @param refreshHistory - Whether to refresh the history list
+   */
+  onShowRunId?: (runId: string, refreshHistory?: boolean) => void;
+  /** Initial run ID to display (optional) */
+  initialRunId?: string;
+  /** Initial state for history panel (default: false) */
+  initialHistoryOpen?: boolean;
+}
+/**
+ * Provider for run action context.
+ *
+ * This is a props-driven provider designed for library consumers.
+ * Pass your own `onRunAction` handler to execute runs.
+ *
+ * @example
+ * ```tsx
+ * const handleRunAction = async (type, params, options) => {
+ *   const response = await api.submitRun(type, params);
+ *   return response.run_id;
+ * };
+ *
+ * <RecceActionProvider onRunAction={handleRunAction}>
+ *   <LineageView />
+ * </RecceActionProvider>
+ * ```
+ */
+declare function RecceActionProvider({
+  children,
+  onRunAction,
+  onShowRunId,
+  initialRunId,
+  initialHistoryOpen
+}: RecceActionProviderProps): react_jsx_runtime130.JSX.Element;
+/**
+ * Hook to access the RecceAction context.
+ *
+ * @returns RecceActionContextType with run action methods and state
+ */
+declare function useRecceActionContext(): RecceActionContextType;
+//#endregion
+//#region src/contexts/idle/types.d.ts
+/**
+ * Context for sharing idle timeout state across components
+ *
+ * IMPORTANT: The countdown is based on the last SUCCESSFUL keep-alive API call,
+ * NOT on user activity. This ensures the countdown accurately reflects the
+ * server's idle timeout state.
+ */
+interface IdleTimeoutContextType {
+  /** Remaining seconds until timeout (null if idle timeout not enabled) */
+  remainingSeconds: number | null;
+  /** Idle timeout value from server in seconds (null if not configured) */
+  idleTimeout: number | null;
+  /** Whether idle timeout is enabled */
+  isEnabled: boolean;
+  /** Mark as disconnected - stops countdown and keep-alive */
+  setDisconnected: () => void;
+  /** Reset connection state - restarts countdown and keep-alive after successful reconnect */
+  resetConnection: () => void;
+  /** Whether the connection is disconnected */
+  isDisconnected: boolean;
+}
+/**
+ * Hook to access idle timeout context, returns null if outside provider
+ * Used internally by useIdleDetection to avoid circular dependency
+ */
+declare function useIdleTimeoutSafe(): IdleTimeoutContextType | null;
+//#endregion
+//#region src/contexts/idle/IdleTimeoutContext.d.ts
+/**
+ * Provider for idle timeout state
+ *
+ * The countdown is based on lastServerSyncTime (when keep-alive API was last
+ * successfully sent), not on user activity. This provides accurate server state.
+ */
+declare function IdleTimeoutProvider({
+  children
+}: {
+  children: ReactNode;
+}): react_jsx_runtime130.JSX.Element;
+/**
+ * Hook to access idle timeout context
+ * @throws Error if used outside IdleTimeoutProvider
+ */
+declare function useIdleTimeout(): IdleTimeoutContextType;
+//#endregion
+//#region src/contexts/idle/useIdleDetection.d.ts
+/**
+ * Hook to detect user activity and send keep-alive signals to prevent server idle timeout.
+ *
+ * This hook:
+ * - Listens for user activities (focus, mouse, keyboard, scroll)
+ * - Sends keep-alive requests (throttled at axios layer to minimum 3 seconds)
+ * - Pauses when the tab is inactive (using Page Visibility API)
+ * - Immediately sends a keep-alive when tab becomes active
+ * - Only activates when idle_timeout is configured on the server
+ *
+ * Note: The countdown in IdleTimeoutContext is based on successful keep-alive
+ * API calls, not on user activity. This ensures accurate server state tracking.
+ */
+declare function useIdleDetection(): void;
+//#endregion
+//#region src/contexts/instance/types.d.ts
+/**
+ * Feature mode for the Recce instance.
+ * - "read only": No modifications allowed
+ * - "metadata only": Database queries disabled
+ * - null: Full functionality enabled
+ */
+type RecceFeatureMode = "read only" | "metadata only" | null;
+/**
+ * Feature toggles that control what actions are available in the UI.
+ * These are derived from the server's instance info based on server mode.
+ */
+interface RecceFeatureToggles {
+  /** Current feature mode based on server_mode */
+  mode: RecceFeatureMode;
+  /** Disable saving state to file */
+  disableSaveToFile: boolean;
+  /** Disable exporting state file */
+  disableExportStateFile: boolean;
+  /** Disable importing state file */
+  disableImportStateFile: boolean;
+  /** Disable updating checklist */
+  disableUpdateChecklist: boolean;
+  /** Disable database query execution */
+  disableDatabaseQuery: boolean;
+  /** Disable view action dropdown menu */
+  disableViewActionDropdown: boolean;
+  /** Disable node action dropdown menu */
+  disableNodeActionDropdown: boolean;
+  /** Disable share functionality */
+  disableShare: boolean;
+}
+/**
+ * Instance information exposed through the RecceInstanceContext.
+ * Contains feature toggles and session information.
+ */
+interface InstanceInfoType {
+  /** Whether running in single environment mode */
+  singleEnv: boolean;
+  /** Whether user is authenticated */
+  authed: boolean;
+  /** Feature toggles based on server mode */
+  featureToggles: RecceFeatureToggles;
+  /** When the instance lifetime expires */
+  lifetimeExpiredAt?: Date;
+  /** URL for sharing the instance */
+  shareUrl?: string;
+  /** Current session ID */
+  sessionId?: string;
+}
+/**
+ * Default feature toggles with all features enabled.
+ */
+declare const defaultFeatureToggles: RecceFeatureToggles;
+/**
+ * Default instance info values.
+ */
+declare const defaultInstanceInfo: InstanceInfoType;
+//#endregion
+//#region src/contexts/instance/RecceInstanceContext.d.ts
+/**
+ * Provider that fetches and processes Recce instance information.
+ *
+ * This provider:
+ * 1. Fetches instance info from the server using useRecceInstanceInfo
+ * 2. Computes feature toggles based on server_mode
+ * 3. Provides the processed data through context
+ *
+ * Feature toggles are computed based on:
+ * - server_mode: "read-only" disables all modifications
+ * - server_mode: "preview" disables database queries but allows metadata operations
+ * - single_env: disables checklist updates and sharing
+ * - cloud_instance: disables sharing
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   return (
+ *     <RecceProvider api={{ baseUrl: "/api" }}>
+ *       <RecceInstanceInfoProvider>
+ *         <MyComponent />
+ *       </RecceInstanceInfoProvider>
+ *     </RecceProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function RecceInstanceInfoProvider({
+  children
+}: {
+  children: ReactNode;
+}): react_jsx_runtime130.JSX.Element;
+/**
+ * Hook to access the Recce instance context.
+ *
+ * Returns the current instance information including feature toggles,
+ * authentication status, and session information.
+ *
+ * @returns InstanceInfoType with feature toggles and session info
+ *
+ * @example
+ * ```tsx
+ * function FeatureGate() {
+ *   const { featureToggles } = useRecceInstanceContext();
+ *
+ *   if (featureToggles.disableDatabaseQuery) {
+ *     return <div>Database queries are disabled</div>;
+ *   }
+ *
+ *   return <QueryEditor />;
+ * }
+ * ```
+ */
+declare function useRecceInstanceContext(): InstanceInfoType;
+//#endregion
+//#region src/contexts/instance/useRecceInstanceInfo.d.ts
+/**
+ * Hook to fetch Recce instance information from the server.
+ *
+ * Uses TanStack Query to cache the response and the configured API client.
+ * Works both inside RecceProvider (uses configured client) and outside (uses default axios).
+ *
+ * @returns Query result with RecceInstanceInfo data
+ *
+ * @example
+ * ```tsx
+ * function InstanceStatus() {
+ *   const { data, isLoading, error } = useRecceInstanceInfo();
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *   if (error) return <div>Error loading instance info</div>;
+ *
+ *   return <div>Server mode: {data?.server_mode}</div>;
+ * }
+ * ```
+ */
+declare function useRecceInstanceInfo(): _tanstack_react_query5.UseQueryResult<RecceInstanceInfo, Error>;
+//#endregion
+export { AxiosQueryParams as _, RecceFeatureMode as a, SubmitRunTrackProps as b, defaultInstanceInfo as c, useIdleTimeout as d, IdleTimeoutContextType as f, useRecceActionContext as g, RecceActionProviderProps as h, InstanceInfoType as i, useIdleDetection as l, RecceActionProvider as m, RecceInstanceInfoProvider as n, RecceFeatureToggles as o, useIdleTimeoutSafe as p, useRecceInstanceContext as r, defaultFeatureToggles as s, useRecceInstanceInfo as t, IdleTimeoutProvider as u, RecceActionContextType as v, RecceActionOptions as y };
+//# sourceMappingURL=index-DVoQsx5c.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-DVoQsx5c.d.ts","names":[],"sources":["../src/contexts/action/types.ts","../src/contexts/action/RecceActionContext.tsx","../src/contexts/idle/types.ts","../src/contexts/idle/IdleTimeoutContext.tsx","../src/contexts/idle/useIdleDetection.ts","../src/contexts/instance/types.ts","../src/contexts/instance/RecceInstanceContext.tsx","../src/contexts/instance/useRecceInstanceInfo.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index-DmwYRgDR.d.ts

@@ -0,0 +1,192 @@
+
+import * as react49 from "react";
+import { MouseEvent, ReactNode } from "react";
+import * as react_jsx_runtime119 from "react/jsx-runtime";
+import { Edge, EdgeProps } from "@xyflow/react";
+
+//#region src/components/lineage/edges/LineageEdge.d.ts
+type EdgeChangeStatus = "added" | "removed" | "modified" | "unchanged";
+interface LineageEdgeData extends Record<string, unknown> {
+  /** Change status for diff visualization */
+  changeStatus?: EdgeChangeStatus;
+  /** Whether this edge is highlighted */
+  isHighlighted?: boolean;
+  /** Label to display on edge */
+  label?: string;
+}
+type LineageEdgeType = Edge<LineageEdgeData>;
+type LineageEdgeProps = EdgeProps<LineageEdgeType>;
+declare function LineageEdgeComponent({
+  id,
+  sourceX,
+  sourceY,
+  targetX,
+  targetY,
+  sourcePosition,
+  targetPosition,
+  data,
+  selected
+}: LineageEdgeProps): react_jsx_runtime119.JSX.Element;
+declare const LineageEdge: react49.MemoExoticComponent<typeof LineageEdgeComponent>;
+//#endregion
+//#region src/components/lineage/nodes/LineageNode.d.ts
+/**
+ * Change status for node visualization
+ */
+type NodeChangeStatus = "added" | "removed" | "modified" | "unchanged";
+/**
+ * Selection mode for the node
+ */
+type SelectMode = "normal" | "selecting" | "action_result";
+/**
+ * Change category from column-level lineage analysis
+ */
+type ChangeCategory = "breaking" | "non_breaking" | "partial_breaking" | "unknown";
+/**
+ * Data structure for lineage node
+ */
+interface LineageNodeData extends Record<string, unknown> {
+  /** Display label for the node */
+  label: string;
+  /** Node type (model, source, seed, etc.) */
+  nodeType?: string;
+  /** Change status for diff visualization */
+  changeStatus?: NodeChangeStatus;
+  /** Whether this node is currently selected */
+  isSelected?: boolean;
+  /** Resource type for icon display */
+  resourceType?: string;
+  /** Package name */
+  packageName?: string;
+  /** Whether to show column-level details */
+  showColumns?: boolean;
+  /** Column data if showing columns */
+  columns?: Array<{
+    name: string;
+    type?: string;
+    changeStatus?: NodeChangeStatus;
+  }>;
+}
+/**
+ * Props for LineageNode component
+ */
+interface LineageNodeProps {
+  /** Node ID */
+  id: string;
+  /** Node data */
+  data: LineageNodeData;
+  /** Whether the node is selected (from React Flow) */
+  selected?: boolean;
+  /** Enable interactive mode with checkbox */
+  interactive?: boolean;
+  /** Selection mode */
+  selectMode?: SelectMode;
+  /** Whether the node is selected (checkbox state) */
+  isNodeSelected?: boolean;
+  /** Whether the node is focused */
+  isFocused?: boolean;
+  /** Whether the node is highlighted */
+  isHighlighted?: boolean;
+  /** Whether to show content (zoom level visibility) */
+  showContent?: boolean;
+  /** Action tag to display (for action_result mode) */
+  actionTag?: ReactNode;
+  /** Whether to show change analysis mode */
+  showChangeAnalysis?: boolean;
+  /** Change category text */
+  changeCategory?: ChangeCategory;
+  /** Runs aggregated display component */
+  runsAggregatedTag?: ReactNode;
+  /** Whether node has parent nodes (show left handle) */
+  hasParents?: boolean;
+  /** Whether node has child nodes (show right handle) */
+  hasChildren?: boolean;
+  /** Number of columns for column container height */
+  columnCount?: number;
+  /** Height per column in pixels */
+  columnHeight?: number;
+  /** Whether dark mode is active */
+  isDark?: boolean;
+  /** Callback when node is clicked */
+  onNodeClick?: (nodeId: string) => void;
+  /** Callback when node is double-clicked */
+  onNodeDoubleClick?: (nodeId: string) => void;
+  /** Callback when checkbox is clicked */
+  onSelect?: (nodeId: string) => void;
+  /** Callback when context menu is requested */
+  onContextMenu?: (event: MouseEvent, nodeId: string) => void;
+  /** Callback when impact radius button is clicked */
+  onShowImpactRadius?: (nodeId: string) => void;
+}
+/**
+ * LineageNode - Pure presentation component for displaying nodes in a lineage graph
+ *
+ * This component is designed to be used with @xyflow/react and receives all data via props.
+ * It does not perform any data fetching or state management - it is purely presentational.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <LineageNode
+ *   id="model.my_model"
+ *   data={{
+ *     label: "my_model",
+ *     nodeType: "model",
+ *     changeStatus: "modified",
+ *     resourceType: "model"
+ *   }}
+ *   selected={false}
+ *   onNodeClick={(nodeId) => console.log("Clicked:", nodeId)}
+ * />
+ * ```
+ *
+ * @example Interactive mode with selection
+ * ```tsx
+ * <LineageNode
+ *   id="model.my_model"
+ *   data={{ label: "my_model", changeStatus: "added" }}
+ *   interactive
+ *   selectMode="selecting"
+ *   isNodeSelected={selectedNodes.has("model.my_model")}
+ *   onSelect={(nodeId) => toggleSelection(nodeId)}
+ * />
+ * ```
+ *
+ * @example Action result mode
+ * ```tsx
+ * <LineageNode
+ *   id="model.my_model"
+ *   data={{ label: "my_model", changeStatus: "modified" }}
+ *   selectMode="action_result"
+ *   actionTag={<ActionTag status="running" progress={{ percentage: 0.5 }} />}
+ * />
+ * ```
+ */
+declare function LineageNodeComponent({
+  id,
+  data,
+  selected,
+  interactive,
+  selectMode,
+  isNodeSelected,
+  isFocused,
+  isHighlighted,
+  showContent,
+  actionTag,
+  showChangeAnalysis,
+  changeCategory,
+  runsAggregatedTag,
+  hasParents,
+  hasChildren,
+  columnCount,
+  columnHeight,
+  isDark,
+  onNodeClick,
+  onNodeDoubleClick,
+  onSelect,
+  onContextMenu,
+  onShowImpactRadius
+}: LineageNodeProps): react_jsx_runtime119.JSX.Element;
+declare const LineageNode: react49.MemoExoticComponent<typeof LineageNodeComponent>;
+//#endregion
+export { EdgeChangeStatus as a, LineageEdgeProps as c, NodeChangeStatus as i, LineageNodeData as n, LineageEdge as o, LineageNodeProps as r, LineageEdgeData as s, LineageNode as t };
+//# sourceMappingURL=index-DmwYRgDR.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-DmwYRgDR.d.ts","names":[],"sources":["../src/components/lineage/edges/LineageEdge.tsx","../src/components/lineage/nodes/LineageNode.tsx"],"sourcesContent":[],"mappings":";;;;;;;KAWY,gBAAA;UAEK,eAAA,SAAwB;;iBAExB;;EAJL,aAAA,CAAA,EAAA,OAAgB;EAEX;EASL,KAAA,CAAA,EAAA,MAAA;AAEZ;AASS,KAXG,eAAA,GAAkB,IAWD,CAXM,eAWN,CAAA;AAC3B,KAVU,gBAAA,GAAmB,SAU7B,CAVuC,eAUvC,CAAA;iBADO,oBAAA,CAEP;EAAA,EAAA;EAAA,OAAA;EAAA,OAAA;EAAA,OAAA;EAAA,OAAA;EAAA,cAAA;EAAA,cAAA;EAAA,IAAA;EAAA;AAAA,CAAA,EAQC,gBARD,CAAA,EAQiB,oBAAA,CAAA,GAAA,CAAA,OARjB;AACA,cA0DW,WA1DX,EA0DsB,OAAA,CAAA,mBA1DtB,CAAA,OA0DsB,oBA1DtB,CAAA;;;;;;KCCU,gBAAA;;AD1BZ;AAEA;AASY,KCoBA,UAAA,GDpBe,QAAA,GAAQ,WAAA,GAAA,eAAD;AAElC;AAA0D;;AAWxD,KCYU,cAAA,GDZV,UAAA,GAAA,cAAA,GAAA,kBAAA,GAAA,SAAA;;;;AAIA,UCiBe,eAAA,SAAwB,MDjBvC,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA;EACA;EACA,KAAA,EAAA,MAAA;EACA;EACC,QAAA,CAAA,EAAA,MAAA;EAAgB;EAAA,YAAA,CAAA,ECmBF,gBDnBE;EAmDN;;;;ECzDD;EAKA,WAAA,CAAA,EAAU,MAAA;EAKV;EASK,WAAA,CAAA,EAAA,OAAgB;EAMhB;EAaE,OAAA,CAAA,EAHP,KAGO,CAAA;IAHP,IAAA,EAAA,MAAA;IAhB6B,IAAA,CAAA,EAAA,MAAA;IAAM,YAAA,CAAA,EAmB5B,gBAnB4B;EA0B9B,CAAA,CAAA;;;;;AA8BK,UA9BL,gBAAA,CA8BK;EAwBI;EAAU,EAAA,EAAA,MAAA;EA2I3B;EACP,IAAA,EA9LM,eA8LN;EACA;EACA,QAAA,CAAA,EAAA,OAAA;EAEA;EACA,WAAA,CAAA,EAAA,OAAA;EACA;EACA,UAAA,CAAA,EA7La,UA6Lb;EACA;EACA,cAAA,CAAA,EAAA,OAAA;EAEA;EACA,SAAA,CAAA,EAAA,OAAA;EACA;EACA,aAAA,CAAA,EAAA,OAAA;EAEA;EACA,WAAA,CAAA,EAAA,OAAA;EACA;EACA,SAAA,CAAA,EA7LY,SA6LZ;EAEA;EAEA,kBAAA,CAAA,EAAA,OAAA;EACA;EACA,cAAA,CAAA,EA/LiB,cA+LjB;EACA;EACA,iBAAA,CAAA,EA/LoB,SA+LpB;EACC;EAAgB,UAAA,CAAA,EAAA,OAAA;EAAA;EAyUN,WAAA,CAAA,EAAwC,OAAA;;;;;;;;;;;;;;0BAjf3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2IjB,oBAAA;;;;;;;;;;;;;;;;;;;;;;;;GA6BN,mBAAgB,oBAAA,CAAA,GAAA,CAAA;cAyUN,aAAW,OAAA,CAAA,2BAAA"}

package/dist/index-N8N7XmRj.d.ts

@@ -0,0 +1,130 @@
+
+import * as _mui_material_styles0 from "@mui/material/styles";
+import { Theme } from "@mui/material/styles";
+import * as ag_grid_community0 from "ag-grid-community";
+
+//#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/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_material_styles0.Theme;
+/**
+ * Theme type export for consumers who need to type their theme
+ */
+type RecceTheme = typeof theme;
+//#endregion
+export { getThemedPluginOptions as _, BASE_BAR_COLOR_DARK as a, dataGridThemeLight as b, CURRENT_BAR_COLOR as c, CURRENT_BAR_COLOR_WITH_ALPHA as d, ChartThemeColors as f, getChartThemeColors as g, getBarColors as h, BASE_BAR_COLOR as i, CURRENT_BAR_COLOR_DARK as l, INFO_VAL_COLOR_DARK as m, RecceTheme as n, BASE_BAR_COLOR_DARK_WITH_ALPHA as o, INFO_VAL_COLOR as p, theme as r, BASE_BAR_COLOR_WITH_ALPHA as s, Theme as t, CURRENT_BAR_COLOR_DARK_WITH_ALPHA as u, getThemedScaleOptions as v, dataGridThemeDark as y };
+//# sourceMappingURL=index-N8N7XmRj.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-N8N7XmRj.d.ts","names":[],"sources":["../src/components/data/agGridTheme.ts","../src/theme/chartTheme.ts","../src/theme/theme.ts"],"sourcesContent":[],"mappings":";;;;;;;;;cAkBa,oBAAkB,kBAAA,CAAA,MAY7B,kBAAA,CAZ6B,kBAAA;;AAA/B;AAiBA;cAAa,mBAAiB,kBAAA,CAAA,MAY5B,kBAAA,CAZ4B,kBAAA;;;;;;UC/Bb,gBAAA;;EDcJ,SAAA,EAAA,MAAA;EAiBA,WAAA,EAAA,MAAA;;;;AC/Bb;AAaA;AAgBA;AAqBA;AAsBA;AACa,iBA5DG,mBAAA,CA4DW,MAAA,EAAA,OAAA,CAAA,EA5D2B,gBA4D3B;AAC3B;AACA;AAGA;AACA;AACA;AACA;AAGa,iBAvDG,qBAAA,CAuDW,MAAA,EAAA,OAAA,EAAA,QAAA,CAAA,EAAA,OAAA,CAAA,EAAA;EACd,IAAA,EAAA;IAOG,KAAA,EAAA,MAAY,GAAA,SAAA;;;;IC+ff,KAuMX,EAAA,MAAA;EAKU,CAAA;;;;;;;;;;iBDrvBI,sBAAA;;;;;;;;;;;;;;;;;cAsBH,iBAAA;cACA,cAAA;cACA,4BAAA;cACA,yBAAA;cAGA,sBAAA;cACA,mBAAA;cACA,iCAAA;cACA,8BAAA;cAGA,cAAA;cACA,mBAAA;;;;;;iBAOG,YAAA;;;;;;;;;;;;;;AD9EhB;AAiBA;;;;AC/BA;AAaA;AAgBA;AAqBA;AAsBA;AACA;AACA;AACA;AAGA;AACA;AACA;AACA;AAGA;AACA;AAOA;;cC+fa,OAuMX,qBAAA,CAvMgB;;AAAlB;AA4MA;KAAY,UAAA,UAAoB"}