@upbound/monarch-blocks 0.5.0 → 0.6.0

package/dist/graph.d.ts

@@ -0,0 +1,182 @@
+import { Node, NodeProps, Edge, EdgeProps, NodeTypes, EdgeTypes } from 'reactflow';
+export { Edge, Node } from 'reactflow';
+import * as React from 'react';
+import { ColumnDef, ColumnFiltersState } from '@tanstack/react-table';
+import { D as DataTableEmptyConfig, T as TableDataState } from './empty-view-DO36LNvk.js';
+import '@upbound/monarch-core';
+
+type GraphBadgeVariant = 'default' | 'secondary' | 'destructive' | 'outline' | 'ghost' | 'link' | 'healthy' | 'unhealthy' | 'warning' | 'stale' | 'info' | 'unknown';
+type BadgeWithTooltip = {
+    variant?: GraphBadgeVariant;
+    tooltipContent?: string;
+    children: React.ReactNode;
+};
+interface NodeData<T extends object = object> {
+    rawData: T;
+    title: string;
+    subtitle: string;
+    name: string;
+    typeDescriptors: {
+        className?: string;
+        default: string;
+        compact?: string;
+    };
+    badges: {
+        default: BadgeWithTooltip[];
+        compact?: BadgeWithTooltip[];
+    };
+    compact?: boolean;
+    state?: 'default' | 'progressing' | 'paused';
+    onClick?: (nodeId: string, data: NodeData) => void;
+    expanded?: boolean;
+    onExpandToggle?: (nodeId: string) => void;
+    isExpandable?: boolean;
+    isHighlighted?: boolean;
+}
+type NodeLoading = Node & {
+    type: 'loading';
+    data?: {};
+};
+type NodeDefault<T extends object = object> = Node<NodeData<T>> & {
+    type?: 'default';
+};
+declare function isDefaultNode(node: NodeLoading | NodeDefault): node is NodeDefault;
+type GraphNodeProps<T extends NodeData | {}> = NodeProps<T>;
+declare function GraphNode<T extends NodeData = NodeData>({ id, data, ...props }: GraphNodeProps<T>): React.JSX.Element;
+declare function GraphNodeSkeleton(_props: NodeProps<{}>): React.JSX.Element;
+
+interface GraphActionsProviderProps {
+    initialNodes?: (NodeLoading | NodeDefault)[];
+    initialEdges?: Edge[];
+    children: React.ReactNode;
+}
+interface GraphActionsProviderRef {
+    addNodes: (newNodes: (NodeLoading | NodeDefault)[]) => void;
+    addEdges: (newEdges: Edge[]) => void;
+    setNodes: (nodes: (NodeLoading | NodeDefault)[]) => void;
+    setEdges: (edges: Edge[]) => void;
+    toggleNodeExpansion: (nodeId: string) => void;
+    updateNode: (nodeId: string, node: NodeLoading | NodeDefault) => void;
+    reset: () => void;
+}
+declare const GraphActionsProvider: React.ForwardRefExoticComponent<GraphActionsProviderProps & React.RefAttributes<GraphActionsProviderRef>>;
+
+declare const GraphEdge: React.FC<EdgeProps & {
+    stopOpacity?: number;
+}>;
+
+interface GraphOptions<T extends object> {
+    data: T[];
+    nodeTransform: (item: T, data: T[]) => NodeLoading | NodeDefault | (NodeLoading | NodeDefault)[];
+    edgeTransform: (item: T) => Edge[] | undefined;
+    nodeTypes?: NodeTypes;
+    edgeTypes?: EdgeTypes;
+}
+type GraphDataState = TableDataState;
+interface GraphEmptyView {
+    empty?: DataTableEmptyConfig;
+    error?: DataTableEmptyConfig;
+    filter?: DataTableEmptyConfig;
+}
+interface GraphProps<T extends object> {
+    id: string;
+    viewportFocusNodeId?: string;
+    config: GraphOptions<T>;
+    columnDefinitions?: ColumnDef<T, unknown>[];
+    title?: React.ReactNode;
+    loading?: boolean;
+    showError?: boolean;
+    className?: string;
+    emptyView?: GraphEmptyView;
+    ActionsComponent?: React.ComponentType<{
+        state: GraphDataState;
+    }>;
+    disableSearch?: boolean;
+    disableFilters?: boolean;
+    searchTerm?: string;
+    onSearchTermChange?: React.Dispatch<React.SetStateAction<string>>;
+    filters?: ColumnFiltersState;
+    onFiltersChange?: React.Dispatch<React.SetStateAction<ColumnFiltersState>>;
+}
+declare const defaultGraphErrorConfig: DataTableEmptyConfig;
+declare const defaultGraphEmptyConfig: DataTableEmptyConfig;
+declare const defaultGraphNoFilterFoundConfig: DataTableEmptyConfig;
+declare function Graph<T extends object>({ id, viewportFocusNodeId, config, columnDefinitions, title, emptyView, showError, className, loading, ActionsComponent: Actions, disableSearch, disableFilters, searchTerm: parentGlobalFilter, onSearchTermChange: parentSetGlobalFilter, filters: parentColumnFilters, onFiltersChange: parentSetColumnFilters, children, }: React.PropsWithChildren<GraphProps<T>>): React.JSX.Element;
+
+declare const GraphView: React.ForwardRefExoticComponent<{
+    viewportFocusNodeId?: string;
+    defaultNodes?: (NodeLoading | NodeDefault)[];
+    defaultEdges?: Edge[];
+    nodeTypes?: NodeTypes;
+    edgeTypes?: EdgeTypes;
+    children?: React.ReactNode;
+} & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<GraphActionsProviderRef>>;
+
+/**
+ * Auto Layout Algorithm for Graph Positioning
+ *
+ * This hook implements a tree-based layout algorithm that positions nodes in a hierarchical graph.
+ * The algorithm ensures proper spacing and positioning by finding the actual lowest positioned nodes.
+ *
+ * Flow Overview:
+ * 1. Filter visible nodes (exclude hidden nodes from layout calculations)
+ * 2. Build tree structure from nodes and edges using getTrees()
+ * 3. Position nodes recursively with positionNodes():
+ *    - Calculate X position based on node depth in hierarchy
+ *    - Calculate Y position based on actual lowest positioned node in previous sibling's subtree
+ *    - Use getLowestPositionYInSubtree() to find the real bottom of each subtree
+ * 4. Flatten positioned tree back to array of nodes
+ * 5. Return only visible nodes with their calculated positions
+ *
+ * Key Features:
+ * - Sibling nodes are positioned below the actual lowest node in previous sibling's entire subtree
+ * - Uses Math.max to find the deepest positioned node across all child subtrees
+ * - Proper horizontal spacing based on hierarchy depth
+ * - Vertical spacing prevents node overlapping by using real node positions
+ * - Hidden nodes are completely excluded from ReactFlow
+ * - Loading nodes are properly displayed when parent is expanded
+ *
+ */
+
+interface AutoLayoutReturn {
+    nodes: (NodeLoading | NodeDefault)[];
+    edges: Edge[];
+    nodeMap: Map<string, NodeLoading | NodeDefault>;
+}
+declare const useAutoLayout: (nodes: (NodeLoading | NodeDefault)[], edges: Edge[], { viewportFocusNodeId }: {
+    viewportFocusNodeId?: string;
+}) => AutoLayoutReturn;
+
+interface UseNodeVisibilityReturn {
+    nodes: (NodeLoading | NodeDefault)[];
+    edges: Edge[];
+}
+declare const useNodeVisibility: (nodes: (NodeLoading | NodeDefault)[], edges: Edge[]) => UseNodeVisibilityReturn;
+
+interface GraphActions {
+    nodes: (NodeLoading | NodeDefault)[];
+    edges: Edge[];
+    addNodes: (newNodes: (NodeLoading | NodeDefault)[]) => void;
+    addEdges: (newEdges: Edge[]) => void;
+    removeNodes: (nodeIds: string[]) => void;
+    removeEdges: (edgeIds: string[]) => void;
+    setNodes: (nodes: (NodeLoading | NodeDefault)[]) => void;
+    setEdges: (edges: Edge[]) => void;
+    updateNode: (nodeId: string, node: NodeLoading | NodeDefault) => void;
+    toggleNodeExpansion: (nodeId: string) => void;
+    resetGraph: () => void;
+}
+declare const useGraphActions: (initialNodes?: (NodeLoading | NodeDefault)[], initialEdges?: Edge[]) => GraphActions;
+
+declare const useGraphActionsContext: () => GraphActions;
+
+declare const useGetViewportNodeIds: (debounceDelay?: number) => string[];
+
+declare const getGraphDescendants: (node: Node, nodes: Node[], edges: Edge[]) => {
+    nodes: Node[];
+    edges: Edge[];
+};
+
+export { type AutoLayoutReturn, Graph, type GraphActions, GraphActionsProvider, type GraphActionsProviderRef, type GraphBadgeVariant, type GraphDataState, GraphEdge, type GraphEmptyView, GraphNode, type GraphNodeProps, GraphNodeSkeleton, type GraphOptions, type GraphProps, GraphView, type NodeData, type NodeDefault, type NodeLoading, type UseNodeVisibilityReturn, defaultGraphEmptyConfig, defaultGraphErrorConfig, defaultGraphNoFilterFoundConfig, getGraphDescendants, isDefaultNode, useAutoLayout, useGetViewportNodeIds, useGraphActions, useGraphActionsContext, useNodeVisibility };