@tldiagram/core-ui 1.87.0

package/dist/pages/ViewEditor/components/EditorOverlays.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import { type Node as RFNode } from 'reactflow';
+interface EditorOverlaysProps {
+    connectGhostPos: {
+        x: number;
+        y: number;
+    } | null;
+    clickConnectMode: {
+        sourceNodeId: string;
+        sourceHandle: string;
+        targetHandle?: string;
+    } | null;
+    clickConnectCursorPos: {
+        x: number;
+        y: number;
+    } | null;
+    handleReconnectDrag: {
+        endpoint: 'source' | 'target';
+        fixedNodeId: string;
+        fixedHandle: string;
+        movingHandle: string;
+        cursorPos: {
+            x: number;
+            y: number;
+        };
+    } | null;
+    rfNodes: RFNode[];
+}
+export declare const EditorOverlays: React.FC<EditorOverlaysProps>;
+export {};

package/dist/pages/ViewEditor/components/EmptyCanvasState.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface EmptyCanvasStateProps {
+    isMobile: boolean;
+    hasNodes: boolean;
+}
+export declare const EmptyCanvasState: React.FC<EmptyCanvasStateProps>;
+export {};

package/dist/pages/ViewEditor/context.d.ts

@@ -0,0 +1,13 @@
+import type { LibraryElement, Connector } from '../../types';
+export interface ViewEditorContextValue {
+    viewId: number | null;
+    canEdit: boolean;
+    isOwner: boolean;
+    isFreePlan: boolean;
+    snapToGrid: boolean;
+    setSnapToGrid: (snap: boolean) => void;
+    selectedElement: LibraryElement | null;
+    selectedConnector: Connector | null;
+}
+export declare const ViewEditorContext: import("react").Context<ViewEditorContextValue | null>;
+export declare function useViewEditorContext(): ViewEditorContextValue;

package/dist/pages/ViewEditor/hooks/useCanvasInteractions.d.ts

@@ -0,0 +1,201 @@
+import type { DrawingCanvasHandle } from '../../../components/DrawingCanvas';
+import { type Connection, type Edge as RFEdge, type EdgeChange, type Node as RFNode, type NodeChange, type NodeDragHandler, type OnConnect, type OnConnectStartParams } from 'reactflow';
+import type { Connector, PlacedElement, ViewTreeNode, LibraryElement, ViewLayer, ViewConnector, IncomingViewConnector } from '../../../types';
+interface CanvasInteractionOptions {
+    viewId: number | null;
+    canEdit: boolean;
+    drawingMode: boolean;
+    isMobileLayout: boolean;
+    rfNodesRef: React.MutableRefObject<RFNode[]>;
+    rfEdgesRef: React.MutableRefObject<RFEdge[]>;
+    viewElementsRef: React.MutableRefObject<PlacedElement[]>;
+    viewIdRef: React.MutableRefObject<number | null>;
+    incomingLinksRef: React.MutableRefObject<IncomingViewConnector[]>;
+    treeDataRef: React.MutableRefObject<ViewTreeNode[]>;
+    navigateRef: React.MutableRefObject<(path: string) => void>;
+    containerRef: React.MutableRefObject<HTMLDivElement | null>;
+    interactionSourceIdRef: React.MutableRefObject<number | null>;
+    hoveredZoomRef: React.MutableRefObject<{
+        elementId: number | null;
+        type: 'in' | 'out' | null;
+    } | null>;
+    hoverPanLockedUntilRef: React.MutableRefObject<number>;
+    setViewElements: React.Dispatch<React.SetStateAction<PlacedElement[]>>;
+    setConnectors: React.Dispatch<React.SetStateAction<Connector[]>>;
+    setRfNodes: React.Dispatch<React.SetStateAction<RFNode[]>>;
+    setRfEdges: React.Dispatch<React.SetStateAction<RFEdge[]>>;
+    setLinksMap: React.Dispatch<React.SetStateAction<Record<number, ViewConnector[]>>>;
+    setParentLinksMap: React.Dispatch<React.SetStateAction<Record<number, ViewConnector[]>>>;
+    setHoveredZoom: (val: {
+        elementId: number | null;
+        type: 'in' | 'out' | null;
+    } | null) => void;
+    refreshGrid: () => Promise<void>;
+    refreshElements: () => Promise<void>;
+    stableOnConnectTo: (targetElementId: number) => Promise<void>;
+    existingElementIds: Set<number>;
+    linksMapRef: React.MutableRefObject<Record<number, ViewConnector[]>>;
+    parentLinksMapRef: React.MutableRefObject<Record<number, ViewConnector[]>>;
+    openElementPanel: () => void;
+    closeElementPanel: () => void;
+    openConnectorPanel: () => void;
+    closeConnectorPanel: () => void;
+    selectedElement: LibraryElement | null;
+    selectedEdgeId: number | null;
+    connectors: Connector[];
+    layers: ViewLayer[];
+    setSelectedElement: React.Dispatch<React.SetStateAction<LibraryElement | null>>;
+    setSelectedEdge: (e: Connector | null) => void;
+    setSelectedEdgeId: (id: number | null) => void;
+    setSelectedProxyConnectorDetails: React.Dispatch<React.SetStateAction<import('../../../crossBranch/types').ProxyConnectorDetails | null>>;
+    openProxyConnectorPanel: () => void;
+    closeProxyConnectorPanel: () => void;
+    handleElementDeleted: (id: number) => void;
+    handleElementPermanentlyDeleted: (id: number) => void;
+    handleConnectorDeleted: (id: number) => void;
+    handleUpdateTags: (elementId: number, tags: string[]) => Promise<void>;
+    drawingCanvasRef: React.MutableRefObject<DrawingCanvasHandle | null>;
+    snapToGrid?: boolean;
+    onMoveStateChange?: (isMoving: boolean) => void;
+}
+type PickerState = {
+    x: number;
+    y: number;
+    flowX: number;
+    flowY: number;
+    expandResults?: boolean;
+    mode: 'add' | 'connect';
+};
+type HandleReconnectDragState = {
+    edgeId: string;
+    endpoint: 'source' | 'target';
+    fixedNodeId: string;
+    fixedHandle: string;
+    movingHandle: string;
+    cursorPos: {
+        x: number;
+        y: number;
+    };
+    hoveredNodeId?: string;
+    hoveredHandleId?: string;
+};
+export declare function useCanvasInteractions({ viewId, canEdit, drawingMode: _drawingMode, isMobileLayout: _isMobileLayout, rfNodesRef, rfEdgesRef: _rfEdgesRef, viewElementsRef, viewIdRef, incomingLinksRef, treeDataRef, navigateRef, containerRef, interactionSourceIdRef, hoveredZoomRef, hoverPanLockedUntilRef, setViewElements, setConnectors, setRfNodes, setRfEdges, setLinksMap, setParentLinksMap: _setParentLinksMap, setHoveredZoom, refreshGrid, refreshElements, stableOnConnectTo, existingElementIds, linksMapRef, parentLinksMapRef, openElementPanel: _openElementPanel, closeElementPanel: closeElementPanel, openConnectorPanel: openConnectorPanel, closeConnectorPanel: closeConnectorPanel, selectedElement, selectedEdgeId, connectors, layers, setSelectedElement, setSelectedEdge, setSelectedEdgeId, setSelectedProxyConnectorDetails, openProxyConnectorPanel, closeProxyConnectorPanel, handleElementDeleted, handleElementPermanentlyDeleted, handleConnectorDeleted, handleUpdateTags, drawingCanvasRef, snapToGrid, onMoveStateChange, }: CanvasInteractionOptions): {
+    canvasMenu: {
+        x: number;
+        y: number;
+        flowX: number;
+        flowY: number;
+    } | null;
+    setCanvasMenu: import("react").Dispatch<import("react").SetStateAction<{
+        x: number;
+        y: number;
+        flowX: number;
+        flowY: number;
+    } | null>>;
+    addingElementAt: PickerState | null;
+    setAddingElementAt: import("react").Dispatch<import("react").SetStateAction<PickerState | null>>;
+    connectGhostPos: {
+        x: number;
+        y: number;
+    } | null;
+    clickConnectMode: {
+        sourceNodeId: string;
+        sourceHandle: string;
+        targetHandle?: string;
+    } | null;
+    clickConnectCursorPos: {
+        x: number;
+        y: number;
+    } | null;
+    handleReconnectDrag: HandleReconnectDragState | null;
+    interactionSourceId: number | null;
+    setInteractionSourceId: import("react").Dispatch<import("react").SetStateAction<number | null>>;
+    pendingConnectionSource: number | null;
+    setPendingConnectionSource: import("react").Dispatch<import("react").SetStateAction<number | null>>;
+    reconnectPicking: {
+        edgeId: number;
+        endpoint: "source" | "target";
+    } | null;
+    setReconnectPicking: import("react").Dispatch<import("react").SetStateAction<{
+        edgeId: number;
+        endpoint: "source" | "target";
+    } | null>>;
+    reconnectPickingRef: import("react").MutableRefObject<{
+        edgeId: number;
+        endpoint: "source" | "target";
+    } | null>;
+    connectorLongPressMenu: {
+        edgeId: number;
+        x: number;
+        y: number;
+    } | null;
+    setConnectorLongPressMenu: import("react").Dispatch<import("react").SetStateAction<{
+        edgeId: number;
+        x: number;
+        y: number;
+    } | null>>;
+    screenToFlowPositionRef: import("react").MutableRefObject<(position: import("reactflow").XYPosition) => import("reactflow").XYPosition>;
+    lastMousePosRef: import("react").MutableRefObject<{
+        clientX: number;
+        clientY: number;
+    } | null>;
+    touchStateRef: import("react").MutableRefObject<{
+        touches: Map<number, {
+            x: number;
+            y: number;
+        }>;
+        initialDistance: number;
+        isPinching: boolean;
+        lastMultiTouchWheelTime: number;
+    }>;
+    stableOnZoomIn: (elementId: number) => Promise<void>;
+    stableOnZoomOut: (elementId: number) => Promise<void>;
+    stableOnNavigateToView: (id: number) => void;
+    stableOnHoverZoom: (elementId: number, type: "in" | "out" | null) => void;
+    stableOnRemoveElement: (elementId: number) => Promise<void>;
+    stableOnConnectTo: (targetElementId: number) => Promise<void>;
+    stableOnStartHandleReconnect: (args: {
+        edgeId: string;
+        endpoint: "source" | "target";
+        handleId: string;
+        clientX: number;
+        clientY: number;
+    }) => void;
+    showAddingElementAt: (clientX: number, clientY: number, expandResults?: boolean, mode?: "add" | "connect") => void;
+    onNodesChange: (changes: NodeChange[]) => void;
+    onEdgesChange: (changes: EdgeChange[]) => void;
+    onNodeDragStart: NodeDragHandler;
+    onNodeDrag: NodeDragHandler;
+    onNodeDragStop: NodeDragHandler;
+    onConnect: OnConnect;
+    onConnectStart: (_: React.MouseEvent | React.TouchEvent, { nodeId }: OnConnectStartParams) => void;
+    onConnectEnd: (event: MouseEvent | TouchEvent) => void;
+    onReconnect: (oldConnector: RFEdge, newConnection: Connection) => Promise<void>;
+    onReconnectStart: () => void;
+    onReconnectEnd: () => void;
+    onEdgeClick: (_: React.MouseEvent, rfConnector: RFEdge) => void;
+    onEdgeContextMenu: (e: React.MouseEvent, rfConnector: RFEdge) => void;
+    onPaneClick: (e: React.MouseEvent) => void;
+    onPaneContextMenu: (e: React.MouseEvent) => void;
+    onPaneMouseMove: (e: React.MouseEvent) => void;
+    onMoveStart: () => void;
+    onMove: (_: unknown, viewport: {
+        x: number;
+        y: number;
+        zoom: number;
+    }) => void;
+    onMoveEnd: () => void;
+    onTouchStart: (e: React.TouchEvent) => void;
+    onTouchMove: (e: React.TouchEvent) => void;
+    onTouchEnd: (e: React.TouchEvent) => void;
+    onContainerPointerDown: (e: React.PointerEvent) => void;
+    onContainerPointerMove: (e: React.PointerEvent) => void;
+    onContainerPointerUp: () => void;
+    onDragOver: (e: React.DragEvent) => void;
+    onDrop: (e: React.DragEvent) => Promise<void>;
+    onWheelCapture: (e: React.WheelEvent) => void;
+    handleConfirmNewElement: (name: string) => Promise<void>;
+    handleConfirmExistingElement: (obj: LibraryElement) => Promise<void>;
+    handleConfirmConnectExistingElement: (obj: LibraryElement) => Promise<void>;
+};
+export {};

package/dist/pages/ViewEditor/hooks/useDrawingEngine.d.ts

@@ -0,0 +1,40 @@
+import type { DrawingPath } from '../../../components/DrawingCanvas';
+export declare function useDrawingEngine(viewId: number | null): {
+    drawingMode: boolean;
+    setDrawingMode: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    drawingVisible: boolean;
+    setDrawingVisible: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    drawingPaths: DrawingPath[];
+    setDrawingPaths: import("react").Dispatch<import("react").SetStateAction<DrawingPath[]>>;
+    drawingTool: "select" | "text" | "pencil" | "eraser";
+    setDrawingTool: import("react").Dispatch<import("react").SetStateAction<"select" | "text" | "pencil" | "eraser">>;
+    drawingColor: string;
+    setDrawingColor: import("react").Dispatch<import("react").SetStateAction<string>>;
+    drawingWidth: number;
+    setDrawingWidth: import("react").Dispatch<import("react").SetStateAction<number>>;
+    textEditorState: {
+        canvasX: number;
+        canvasY: number;
+        flowX: number;
+        flowY: number;
+    } | null;
+    setTextEditorState: import("react").Dispatch<import("react").SetStateAction<{
+        canvasX: number;
+        canvasY: number;
+        flowX: number;
+        flowY: number;
+    } | null>>;
+    drawingHistoryRef: import("react").MutableRefObject<DrawingPath[][]>;
+    drawingRedoStackRef: import("react").MutableRefObject<DrawingPath[][]>;
+    handleUndo: () => void;
+    handleRedo: () => void;
+    commitDrawingText: (value: string, state: {
+        canvasX: number;
+        canvasY: number;
+        flowX: number;
+        flowY: number;
+    }) => void;
+    onPathComplete: (path: DrawingPath) => void;
+    onPathDelete: (pathId: string) => void;
+    onPathUpdate: (path: DrawingPath) => void;
+};

package/dist/pages/ViewEditor/hooks/useViewContextNeighbours.d.ts

@@ -0,0 +1,20 @@
+import { type Edge as RFEdge, type Node as RFNode } from 'reactflow';
+import type { PlacedElement } from '../../../types';
+import type { CrossBranchContextSettings, ProxyConnectorDetails, WorkspaceGraphSnapshot } from '../../../crossBranch/types';
+interface Props {
+    snapshot: WorkspaceGraphSnapshot | null;
+    settings: CrossBranchContextSettings;
+    viewId: number | null;
+    viewElements: PlacedElement[];
+    rfNodes: RFNode[];
+    stableOnNavigateToView: (id: number) => void;
+    onSelectProxyDetails: (details: ProxyConnectorDetails) => void;
+    expandedAncestorGroups: Set<string>;
+    onToggleAncestorGroup: (anchorId: string) => void;
+}
+export declare function useViewContextNeighbours({ snapshot, settings, viewId, viewElements, rfNodes, stableOnNavigateToView, onSelectProxyDetails, expandedAncestorGroups, onToggleAncestorGroup, }: Props): {
+    contextNodes: RFNode[];
+    contextConnectors: RFEdge[];
+    proxyConnectorDetailsByKey: Record<string, ProxyConnectorDetails>;
+};
+export {};

package/dist/pages/ViewEditor/hooks/useViewData.d.ts

@@ -0,0 +1,74 @@
+import { type Edge as RFEdge, type Node as RFNode } from 'reactflow';
+import type { ViewTreeNode, PlacedElement, LibraryElement, Connector, IncomingViewConnector, ViewConnector, Tag } from '../../../types';
+interface ViewDataOptions {
+    viewId: number | null;
+    interactionSourceId: number | null;
+    clickConnectMode: {
+        sourceNodeId: string;
+        sourceHandle: string;
+        targetHandle?: string;
+    } | null;
+    selectedEdgeId: number | null;
+    activeTags: string[];
+    hiddenLayerTags: string[];
+    hoveredLayerTags: string[] | null;
+    hoveredLayerColor: string | null;
+    tagColors: Record<string, Tag>;
+    stableOnZoomIn: (elementId: number) => Promise<void>;
+    stableOnZoomOut: (elementId: number) => Promise<void>;
+    stableOnNavigateToView: (id: number) => void;
+    stableOnSelect: (obj: PlacedElement) => void;
+    stableOnOpenCodePreview: (elementId: number) => void;
+    stableOnInteractionStart: (elementId: number) => void;
+    stableOnConnectTo: (targetElementId: number) => Promise<void>;
+    stableOnStartHandleReconnect: (args: {
+        edgeId: string;
+        endpoint: 'source' | 'target';
+        handleId: string;
+        clientX: number;
+        clientY: number;
+    }) => void;
+    stableOnRemoveElement: (elementId: number) => Promise<void>;
+    stableOnHoverZoom: (elementId: number, type: 'in' | 'out' | null) => void;
+    hoveredZoomRef: React.MutableRefObject<{
+        elementId: number | null;
+        type: 'in' | 'out' | null;
+    } | null>;
+}
+export declare function useViewData({ viewId, interactionSourceId, clickConnectMode, selectedEdgeId, activeTags, hiddenLayerTags, hoveredLayerTags, hoveredLayerColor, tagColors, stableOnZoomIn, stableOnZoomOut, stableOnNavigateToView, stableOnSelect, stableOnOpenCodePreview, stableOnInteractionStart, stableOnConnectTo, stableOnStartHandleReconnect, stableOnRemoveElement, stableOnHoverZoom, hoveredZoomRef, }: ViewDataOptions): {
+    view: ViewTreeNode | null | undefined;
+    setView: import("react").Dispatch<import("react").SetStateAction<ViewTreeNode | null | undefined>>;
+    viewElements: PlacedElement[];
+    setViewElements: import("react").Dispatch<import("react").SetStateAction<PlacedElement[]>>;
+    connectors: Connector[];
+    setConnectors: import("react").Dispatch<import("react").SetStateAction<Connector[]>>;
+    rfNodes: RFNode[];
+    setRfNodes: import("react").Dispatch<import("react").SetStateAction<RFNode[]>>;
+    rfEdges: RFEdge[];
+    setRfEdges: import("react").Dispatch<import("react").SetStateAction<RFEdge[]>>;
+    linksMap: Record<number, ViewConnector[]>;
+    setLinksMap: import("react").Dispatch<import("react").SetStateAction<Record<number, ViewConnector[]>>>;
+    parentLinksMap: Record<number, ViewConnector[]>;
+    setParentLinksMap: import("react").Dispatch<import("react").SetStateAction<Record<number, ViewConnector[]>>>;
+    incomingLinks: IncomingViewConnector[];
+    treeData: ViewTreeNode[];
+    allElements: LibraryElement[];
+    libraryRefresh: number;
+    setLibraryRefresh: import("react").Dispatch<import("react").SetStateAction<number>>;
+    existingElementIds: Set<number>;
+    viewElementsRef: import("react").MutableRefObject<PlacedElement[]>;
+    linksMapRef: import("react").MutableRefObject<Record<number, ViewConnector[]>>;
+    parentLinksMapRef: import("react").MutableRefObject<Record<number, ViewConnector[]>>;
+    incomingLinksRef: import("react").MutableRefObject<IncomingViewConnector[]>;
+    treeDataRef: import("react").MutableRefObject<ViewTreeNode[]>;
+    rfNodesRef: import("react").MutableRefObject<RFNode[]>;
+    rfEdgesRef: import("react").MutableRefObject<RFEdge[]>;
+    viewIdRef: import("react").MutableRefObject<number | null>;
+    refreshGrid: () => Promise<void>;
+    refreshElements: () => Promise<void>;
+    handleElementDeleted: (deletedId: number) => void;
+    handleElementPermanentlyDeleted: (deletedId: number) => void;
+    handleElementSaved: (saved: LibraryElement) => void;
+    setAllElements: import("react").Dispatch<import("react").SetStateAction<LibraryElement[]>>;
+};
+export {};

package/dist/pages/ViewEditor/index.d.ts

@@ -0,0 +1,8 @@
+import type { CoreUISlots } from '../../slots';
+import 'reactflow/dist/style.css';
+import { type ViewEditorDemoOptions } from '../../demo/viewEditor';
+interface Props extends CoreUISlots {
+    demoOptions?: ViewEditorDemoOptions;
+}
+export default function ViewEditor(props: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/pages/ViewEditor/utils.d.ts

@@ -0,0 +1,14 @@
+import type { Connector } from '../../types';
+import type { Node as RFNode } from 'reactflow';
+/** Pass-through: the API already returns Connector in the canonical shape. */
+export declare function connectorToConnector(connector: Connector): Connector;
+export declare function findClosestHandles(sourceNode: RFNode, targetNode: RFNode): {
+    sourceHandle: string;
+    targetHandle: string;
+};
+export declare function findClosestHandleToPoint(sourceNode: RFNode, tx: number, ty: number): {
+    sourceHandle: string;
+    targetHandle: string;
+};
+export declare function sanitizeExportFilename(value: string): string;
+export declare function triggerDownload(dataUrl: string, filename: string): void;

package/dist/pages/Views.d.ts

@@ -0,0 +1,6 @@
+interface Props {
+    shareSlot?: React.ReactNode;
+    onShareView?: (viewId: number) => void;
+}
+export default function ViewsPage({ shareSlot, onShareView }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/pages/ViewsGrid.d.ts

@@ -0,0 +1,6 @@
+import 'reactflow/dist/style.css';
+interface Props {
+    onShare?: (viewId: number) => void;
+}
+export default function ViewsGrid({ onShare }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/pkg/importer/mermaid.d.ts

@@ -0,0 +1,7 @@
+import type { PlanConnector, PlanElement } from '@buf/tldiagramcom_diagram.bufbuild_es/diag/v1/workspace_service_pb';
+export interface ParsedImport {
+    elements: PlanElement[];
+    connectors: PlanConnector[];
+    warnings: string[];
+}
+export declare function parseMermaid(code: string): ParsedImport;

package/dist/pkg/importer/mermaid.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/platform/PlatformContext.d.ts

@@ -0,0 +1,6 @@
+import { type ReactNode } from 'react';
+import type { PlatformFeatures } from './types';
+export declare const PlatformProvider: ({ platform, children }: {
+    platform: PlatformFeatures<unknown>;
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/platform/context.d.ts

@@ -0,0 +1,3 @@
+import type { PlatformFeatures } from './types';
+export declare const PlatformContext: import("react").Context<PlatformFeatures<unknown>>;
+export declare function usePlatform(): PlatformFeatures<unknown>;

package/dist/platform/local.d.ts

@@ -0,0 +1,2 @@
+import type { PlatformFeatures } from './types';
+export declare const platform: PlatformFeatures;

package/dist/platform/types.d.ts

@@ -0,0 +1,17 @@
+import type { ComponentType, ReactNode } from 'react';
+export interface PlatformRouteContext<User = unknown> {
+    user: User | null;
+    onLogin?: (user: User) => void;
+    onLogout?: () => void;
+}
+export interface PlatformFeatures<User = unknown> {
+    hasAuth?: boolean;
+    hasBilling?: boolean;
+    initPlatform: (orgId?: string) => Promise<void>;
+    getUpgradePath?: () => string | null;
+    getRoutes: (context: PlatformRouteContext<User>) => ReactNode[];
+    getAuthenticatedRoutes: (context: PlatformRouteContext<User>) => ReactNode[];
+    getSettingsRoutes: (context: PlatformRouteContext<User>) => ReactNode[];
+    AuthLayout: ComponentType<unknown>;
+    connectRealtime?: (...args: unknown[]) => unknown;
+}

package/dist/slots.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @tldiagram/core-ui Extension Point Slots
+ *
+ * Slots are React.ReactNode props that host applications inject into core
+ * components to layer in optional host-app features (sharing, extra tools, etc.)
+ * without modifying the core library.
+ *
+ * Naming convention: `<area>Slot` describes WHERE the content renders.
+ */
+import type { ReactNode } from 'react';
+export interface TopMenuBarSlots {
+    /**
+     * Rendered in the right section of the desktop top bar, before the
+     * settings / user controls. Use for share buttons,
+     * buttons, notification bells, etc.
+     *
+     * @example <AvatarGroup /> or <ShareButton />
+     */
+    rightSlot?: ReactNode;
+    /**
+     * Rendered inside the mobile "Options" bottom-nav menu, after the
+     * default settings items. Use for custom menu items, links, etc.
+     *
+     * @example <MenuItem>My Custom Action</MenuItem>
+     */
+    mobileMenuSlot?: ReactNode;
+    /**
+     * Overrides the default user profile / settings controls.
+     * If provided, the default user avatar will be hidden.
+     */
+    userControlsSlot?: ReactNode;
+}
+export interface ElementPanelSlots {
+    /**
+     * Rendered at the bottom of the ElementPanel body.
+     */
+    elementPanelAfterContentSlot?: ReactNode;
+}
+export interface ConnectorPanelSlots {
+    /**
+     * Rendered at the bottom of the ConnectorPanel body.
+     */
+    connectorPanelAfterContentSlot?: ReactNode;
+}
+export interface ViewFloatingMenuSlots {
+    /**
+     * Overrides or wraps the default Share button.
+     */
+    shareSlot?: ReactNode;
+    /**
+     * Rendered inside the ViewFloatingMenu, after the existing toolbar
+     * buttons. Use for extra buttons, export to SaaS, etc.
+     */
+    toolbarSlot?: ReactNode;
+}
+export interface ViewEditorSlots {
+    /**
+     * Rendered as a fixed overlay on top of the ReactFlow canvas.
+     */
+    canvasOverlaySlot?: ReactNode;
+}
+/**
+ * All extension points collected. Host apps can build a single
+ * "slots" object and pass it down via context or props.
+ */
+export interface CoreUISlots extends TopMenuBarSlots, ElementPanelSlots, ConnectorPanelSlots, ViewFloatingMenuSlots, ViewEditorSlots {
+}

package/dist/theme.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Record<string, any>;
+export default _default;