@nuraly/lumenui 0.1.0

package/dist/src/components/canvas/workflow-canvas.types.d.ts

@@ -0,0 +1,710 @@
+/**
+ * @license
+ * Copyright 2024 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { DataOperation } from './data-node/data-node.types.js';
+export { DataOperation };
+/**
+ * Node types for standard workflow nodes
+ */
+export declare enum WorkflowNodeType {
+    START = "START",
+    END = "END",
+    HTTP_START = "HTTP_START",
+    HTTP_END = "HTTP_END",
+    CHAT_START = "CHAT_START",
+    CHAT_OUTPUT = "CHAT_OUTPUT",
+    FUNCTION = "FUNCTION",
+    HTTP = "HTTP",
+    CONDITION = "CONDITION",
+    DELAY = "DELAY",
+    PARALLEL = "PARALLEL",
+    LOOP = "LOOP",
+    TRANSFORM = "TRANSFORM",
+    SUB_WORKFLOW = "SUB_WORKFLOW",
+    EMAIL = "EMAIL",
+    NOTIFICATION = "NOTIFICATION",
+    DATABASE = "DATABASE",
+    VARIABLE = "VARIABLE",
+    CHATBOT = "CHATBOT",
+    DEBUG = "DEBUG",
+    LLM = "LLM",
+    OCR = "OCR",
+    WEB_SEARCH = "WEB_SEARCH",
+    WEB_CRAWL = "WEB_CRAWL",
+    DOCUMENT_GENERATOR = "DOCUMENT_GENERATOR",
+    FILE_STORAGE = "FILE_STORAGE",
+    EMBEDDING = "EMBEDDING",
+    DOCUMENT_LOADER = "DOCUMENT_LOADER",
+    TEXT_SPLITTER = "TEXT_SPLITTER",
+    VECTOR_WRITE = "VECTOR_WRITE",
+    VECTOR_SEARCH = "VECTOR_SEARCH",
+    CONTEXT_BUILDER = "CONTEXT_BUILDER",
+    GUARDRAIL = "GUARDRAIL",
+    SLACK_SEND_MESSAGE = "SLACK_SEND_MESSAGE",
+    SLACK_GET_CHANNEL_INFO = "SLACK_GET_CHANNEL_INFO",
+    SLACK_LIST_CHANNELS = "SLACK_LIST_CHANNELS",
+    SLACK_ADD_REACTION = "SLACK_ADD_REACTION",
+    SLACK_UPLOAD_FILE = "SLACK_UPLOAD_FILE",
+    RERANKER = "RERANKER",
+    TELEGRAM_SEND = "TELEGRAM_SEND",
+    TELEGRAM_BOT = "TELEGRAM_BOT",
+    SLACK_SOCKET = "SLACK_SOCKET",
+    DISCORD_BOT = "DISCORD_BOT",
+    WHATSAPP_WEBHOOK = "WHATSAPP_WEBHOOK",
+    CUSTOM_WEBSOCKET = "CUSTOM_WEBSOCKET",
+    MCP = "MCP",
+    UI_TABLE = "UI_TABLE",
+    NOTE = "NOTE",
+    FRAME = "FRAME"
+}
+/**
+ * Node types for agent-based workflows
+ */
+export declare enum AgentNodeType {
+    AGENT = "AGENT",
+    TOOL = "TOOL",
+    MEMORY = "MEMORY",
+    CONTEXT_MEMORY = "CONTEXT_MEMORY",
+    PROMPT = "PROMPT",
+    LLM = "AGENT_LLM",
+    RETRIEVER = "RETRIEVER",
+    CHAIN = "CHAIN",
+    ROUTER = "ROUTER",
+    HUMAN_INPUT = "HUMAN_INPUT",
+    OUTPUT_PARSER = "OUTPUT_PARSER",
+    STRUCTURED_OUTPUT = "STRUCTURED_OUTPUT"
+}
+/**
+ * Node types for database designer mode
+ */
+export declare enum DbDesignerNodeType {
+    TABLE = "DB_TABLE",
+    VIEW = "DB_VIEW",
+    INDEX = "DB_INDEX",
+    RELATIONSHIP = "DB_RELATIONSHIP",
+    CONSTRAINT = "DB_CONSTRAINT",
+    QUERY = "DB_QUERY"
+}
+/**
+ * Node types for whiteboard mode
+ */
+export declare enum WhiteboardNodeType {
+    STICKY_NOTE = "WB_STICKY_NOTE",
+    SHAPE_RECTANGLE = "WB_SHAPE_RECTANGLE",
+    SHAPE_CIRCLE = "WB_SHAPE_CIRCLE",
+    SHAPE_DIAMOND = "WB_SHAPE_DIAMOND",
+    SHAPE_TRIANGLE = "WB_SHAPE_TRIANGLE",
+    SHAPE_ARROW = "WB_SHAPE_ARROW",
+    SHAPE_LINE = "WB_SHAPE_LINE",
+    SHAPE_STAR = "WB_SHAPE_STAR",
+    SHAPE_HEXAGON = "WB_SHAPE_HEXAGON",
+    TEXT_BLOCK = "WB_TEXT_BLOCK",
+    IMAGE = "WB_IMAGE",
+    DRAWING = "WB_DRAWING",
+    FRAME = "WB_FRAME",
+    VOTING = "WB_VOTING",
+    MERMAID = "WB_MERMAID",
+    ANCHOR = "WB_ANCHOR",
+    WORKFLOW = "WB_WORKFLOW",
+    DATABASE = "WB_DATABASE"
+}
+/**
+ * Canvas type to differentiate between canvas modes
+ */
+export declare enum CanvasType {
+    WORKFLOW = "WORKFLOW",
+    DATABASE = "DATABASE",
+    WHITEBOARD = "WHITEBOARD"
+}
+/**
+ * Combined node type union
+ */
+export type NodeType = WorkflowNodeType | AgentNodeType | DbDesignerNodeType | WhiteboardNodeType;
+/**
+ * Connection state for long-running/persistent triggers (Telegram, Slack, etc.)
+ */
+export declare enum TriggerConnectionState {
+    DISCONNECTED = "DISCONNECTED",
+    CONNECTING = "CONNECTING",
+    CONNECTED = "CONNECTED",
+    PAUSED = "PAUSED",
+    HANDOFF_PENDING = "HANDOFF_PENDING",
+    ERROR = "ERROR"
+}
+/**
+ * Execution status for nodes and workflows
+ */
+export declare enum ExecutionStatus {
+    IDLE = "IDLE",
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    CANCELLED = "CANCELLED",
+    PAUSED = "PAUSED",
+    WAITING = "WAITING"
+}
+/**
+ * Port types for node connections
+ */
+export declare enum PortType {
+    INPUT = "INPUT",
+    OUTPUT = "OUTPUT",
+    CONFIG = "CONFIG",
+    CONDITIONAL_TRUE = "CONDITIONAL_TRUE",
+    CONDITIONAL_FALSE = "CONDITIONAL_FALSE",
+    CONDITIONAL_DEFAULT = "CONDITIONAL_DEFAULT",
+    LOOP_ITEM = "LOOP_ITEM",
+    LOOP_DONE = "LOOP_DONE",
+    PARALLEL_BRANCH = "PARALLEL_BRANCH",
+    ERROR = "ERROR"
+}
+/**
+ * Port definition for node input/output
+ */
+export interface NodePort {
+    id: string;
+    type: PortType;
+    label?: string;
+    dataType?: string;
+    multiple?: boolean;
+}
+/**
+ * Visual position for nodes
+ */
+export interface Position {
+    x: number;
+    y: number;
+}
+/**
+ * Filter condition for data queries
+ */
+export interface DataFilterCondition {
+    field: string;
+    op: string;
+    value?: unknown;
+}
+/**
+ * Filter group with AND/OR logic
+ */
+export interface DataFilterGroup {
+    and?: (DataFilterCondition | DataFilterGroup)[];
+    or?: (DataFilterCondition | DataFilterGroup)[];
+}
+/**
+ * Sort order for data queries
+ */
+export interface DataSortOrder {
+    field: string;
+    dir: 'ASC' | 'DESC';
+}
+/**
+ * Node configuration - varies by node type
+ */
+export interface NodeConfiguration {
+    [key: string]: unknown;
+    functionId?: string;
+    inputMapping?: Record<string, string>;
+    outputMapping?: Record<string, string>;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    url?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    timeout?: number;
+    httpPath?: string;
+    httpMethods?: Array<'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH'>;
+    httpAuth?: 'none' | 'api_key' | 'bearer' | 'basic';
+    httpCors?: boolean;
+    httpRateLimit?: number;
+    httpRequestSchema?: Record<string, unknown>;
+    httpStatusCode?: number;
+    httpResponseHeaders?: Record<string, string>;
+    httpResponseBody?: string;
+    httpContentType?: string;
+    expression?: string;
+    language?: 'javascript' | 'jsonata' | 'fr';
+    duration?: number;
+    unit?: 'milliseconds' | 'seconds' | 'minutes' | 'hours';
+    iteratorVariable?: string;
+    arrayExpression?: string;
+    maxIterations?: number;
+    transformExpression?: string;
+    agentId?: string;
+    systemPrompt?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    tools?: string[];
+    provider?: 'openai' | 'anthropic' | 'gemini' | 'ollama' | 'local' | 'google';
+    modelName?: string;
+    apiUrlPath?: string;
+    cutoffMode?: 'message' | 'token';
+    maxMessages?: number;
+    conversationIdExpression?: string;
+    toolName?: string;
+    toolConfig?: Record<string, unknown>;
+    operation?: DataOperation;
+    dataSource?: string | null;
+    entity?: string | null;
+    filter?: DataFilterGroup | null;
+    fields?: Record<string, string | number | boolean | null>;
+    select?: string[];
+    orderBy?: DataSortOrder[];
+    limit?: number | null;
+    offset?: number | null;
+    outputVariable?: string;
+    variableOperation?: 'set' | 'get';
+    variableName?: string;
+    value?: unknown;
+    tableName?: string;
+    columns?: Array<{
+        name: string;
+        type: string;
+        nullable?: boolean;
+        defaultValue?: unknown;
+    }>;
+    primaryKey?: string;
+    viewName?: string;
+    query?: string;
+    materialized?: boolean;
+    indexName?: string;
+    indexColumns?: string[];
+    unique?: boolean;
+    indexType?: 'BTREE' | 'HASH' | 'GIN' | 'GIST';
+    relationshipType?: 'ONE_TO_ONE' | 'ONE_TO_MANY' | 'MANY_TO_MANY';
+    sourceColumn?: string;
+    targetColumn?: string;
+    onDelete?: 'CASCADE' | 'SET_NULL' | 'RESTRICT' | 'NO_ACTION';
+    onUpdate?: 'CASCADE' | 'SET_NULL' | 'RESTRICT' | 'NO_ACTION';
+    constraintName?: string;
+    constraintType?: 'UNIQUE' | 'CHECK' | 'FOREIGN_KEY';
+    constraintColumns?: string[];
+    checkExpression?: string;
+    queryName?: string;
+    queryText?: string;
+    parameters?: Array<{
+        name: string;
+        type: string;
+        defaultValue?: unknown;
+    }>;
+    imageSource?: 'base64' | 'url' | 'file' | 'variable';
+    imageVariable?: string;
+    ocrLanguage?: string;
+    detectLayout?: boolean;
+    asyncMode?: boolean;
+    enableFileUpload?: boolean;
+    maxFileSize?: number;
+    maxFiles?: number;
+    allowImages?: boolean;
+    allowDocuments?: boolean;
+    allowText?: boolean;
+    allowAudio?: boolean;
+    allowVideo?: boolean;
+    noteContent?: string;
+    noteBackgroundColor?: string;
+    noteTextColor?: string;
+    noteFontSize?: 'small' | 'medium' | 'large';
+    noteShowBorder?: boolean;
+    frameLabel?: string;
+    frameWidth?: number;
+    frameHeight?: number;
+    frameBackgroundColor?: string;
+    frameBorderColor?: string;
+    frameLabelPosition?: 'top-left' | 'top-center' | 'top-right';
+    frameLabelPlacement?: 'inside' | 'outside';
+    frameShowLabel?: boolean;
+    frameCollapsed?: boolean;
+    /** Stored dimensions when collapsed (for restore) */
+    _frameExpandedWidth?: number;
+    _frameExpandedHeight?: number;
+    slackMethod?: 'webhook' | 'api';
+    botToken?: string;
+    channel?: string;
+    text?: string;
+    webhookUrl?: string;
+    blocks?: unknown;
+    threadTs?: string;
+    unfurlLinks?: boolean;
+    unfurlMedia?: boolean;
+    includeLocale?: boolean;
+    includeNumMembers?: boolean;
+    types?: string;
+    excludeArchived?: boolean;
+    cursor?: string;
+    teamId?: string;
+    timestamp?: string;
+    name?: string;
+    channels?: string;
+    filename?: string;
+    content?: string;
+    fileBase64?: string;
+    filetype?: string;
+    title?: string;
+    initialComment?: string;
+    topK?: number;
+    threshold?: number;
+    memoryType?: 'buffer' | 'semantic' | 'hybrid';
+    tableColumns?: Array<{
+        name: string;
+        key: string;
+        width?: number | string;
+        filterable?: boolean;
+    }>;
+    dataExpression?: string;
+    tablePageSize?: number;
+    tableEnableFilter?: boolean;
+    tableEnableSort?: boolean;
+    tableFixedHeader?: boolean;
+    tableSize?: 'small' | 'normal' | 'large';
+    tableEmptyText?: string;
+    tableWidth?: number;
+    tableHeight?: number;
+    workflowId?: string;
+    workflowName?: string;
+    workflowSteps?: Array<{
+        name: string;
+        type: string;
+    }>;
+    dbTableId?: string;
+    dbTableName?: string;
+    dbTableColumns?: Array<{
+        name: string;
+        type: string;
+        nullable?: boolean;
+    }>;
+    dbPrimaryKey?: string;
+    anchorLabel?: string;
+    onClickAction?: 'none' | 'pan-to-anchor';
+    onClickTargetAnchorId?: string;
+}
+/**
+ * Workflow node definition
+ */
+export interface WorkflowNode {
+    id: string;
+    name: string;
+    type: NodeType;
+    position: Position;
+    configuration: NodeConfiguration;
+    ports: {
+        inputs: NodePort[];
+        configs?: NodePort[];
+        outputs: NodePort[];
+    };
+    metadata?: {
+        description?: string;
+        icon?: string;
+        color?: string;
+        maxRetries?: number;
+        retryDelayMs?: number;
+        timeoutMs?: number;
+    };
+    status?: ExecutionStatus;
+    selected?: boolean;
+    error?: string;
+    /** Agent activity indicator (LLM calls, tool calls) */
+    agentActivity?: {
+        type: 'llm' | 'tool';
+        name?: string;
+        active: boolean;
+    };
+    /** For FRAME nodes: IDs of nodes visually contained within this frame */
+    containedNodeIds?: string[];
+    /** For regular nodes: ID of the frame that contains this node (if any) */
+    parentFrameId?: string | null;
+    /** Trigger connection status for persistent trigger nodes (Telegram, Slack, etc.) */
+    triggerStatus?: {
+        triggerId: string;
+        connectionState: TriggerConnectionState;
+        health?: 'HEALTHY' | 'DEGRADED' | 'UNHEALTHY' | 'UNKNOWN';
+        messagesReceived?: number;
+        lastMessageAt?: string;
+        stateReason?: string;
+    };
+}
+/**
+ * Edge/connection between nodes
+ */
+export interface WorkflowEdge {
+    id: string;
+    sourceNodeId: string;
+    sourcePortId: string;
+    targetNodeId: string;
+    targetPortId: string;
+    label?: string;
+    condition?: string;
+    priority?: number;
+    animated?: boolean;
+    selected?: boolean;
+    status?: ExecutionStatus;
+}
+/**
+ * Complete workflow definition
+ */
+export interface Workflow {
+    id: string;
+    name: string;
+    description?: string;
+    applicationId?: string;
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+    variables?: Record<string, unknown>;
+    viewport?: CanvasViewport;
+    version?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/**
+ * Canvas viewport state
+ */
+export interface CanvasViewport {
+    zoom: number;
+    panX: number;
+    panY: number;
+}
+/**
+ * Canvas interaction modes
+ */
+export declare enum CanvasMode {
+    SELECT = "SELECT",
+    PAN = "PAN",
+    CONNECT = "CONNECT",
+    ADD_NODE = "ADD_NODE"
+}
+/**
+ * Node category for grouping in palette
+ */
+export interface NodeCategory {
+    id: string;
+    name: string;
+    icon?: string;
+    nodeTypes: NodeType[];
+    canvasType?: CanvasType;
+}
+/**
+ * Output variable schema for a node
+ * Describes what variables are available from a node's output
+ */
+export interface OutputVariable {
+    name: string;
+    path: string;
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'any';
+    description: string;
+    children?: OutputVariable[];
+}
+/**
+ * Node template for creating new nodes
+ */
+export interface NodeTemplate {
+    type: NodeType;
+    name: string;
+    description: string;
+    icon: string;
+    color: string;
+    category: string;
+    defaultConfig: NodeConfiguration;
+    defaultPorts: {
+        inputs: NodePort[];
+        configs?: NodePort[];
+        outputs: NodePort[];
+    };
+    /** Output schema describing available variables from this node */
+    outputSchema?: OutputVariable[];
+}
+/**
+ * Canvas events
+ */
+export interface CanvasEvents {
+    'node-selected': {
+        node: WorkflowNode;
+    };
+    'node-deselected': {
+        node: WorkflowNode;
+    };
+    'node-moved': {
+        node: WorkflowNode;
+        position: Position;
+    };
+    'node-added': {
+        node: WorkflowNode;
+    };
+    'node-removed': {
+        node: WorkflowNode;
+    };
+    'node-configured': {
+        node: WorkflowNode;
+        config: NodeConfiguration;
+    };
+    'edge-created': {
+        edge: WorkflowEdge;
+    };
+    'edge-removed': {
+        edge: WorkflowEdge;
+    };
+    'edge-selected': {
+        edge: WorkflowEdge;
+    };
+    'viewport-changed': {
+        viewport: CanvasViewport;
+    };
+    'workflow-changed': {
+        workflow: Workflow;
+    };
+    'connection-started': {
+        nodeId: string;
+        portId: string;
+    };
+    'connection-cancelled': {};
+}
+/**
+ * Default node colors by type
+ */
+export declare const NODE_COLORS: Record<NodeType, string>;
+/**
+ * Default node icons by type
+ */
+export declare const NODE_ICONS: Record<NodeType, string>;
+/**
+ * Node templates for creating new nodes
+ */
+export declare const NODE_TEMPLATES: NodeTemplate[];
+/**
+ * Node categories for palette organization
+ */
+export declare const NODE_CATEGORIES: NodeCategory[];
+/**
+ * Helper to get node template by type
+ */
+export declare function getNodeTemplate(type: NodeType): NodeTemplate | undefined;
+/**
+ * Helper to check if node type is an agent node
+ */
+export declare function isAgentNode(type: NodeType): boolean;
+/**
+ * Helper to check if node type is a workflow node
+ */
+export declare function isWorkflowNode(type: NodeType): boolean;
+/**
+ * Helper to check if node type is a DB designer node
+ */
+export declare function isDbDesignerNode(type: NodeType): boolean;
+/**
+ * Helper to check if node type is a whiteboard node
+ */
+export declare function isWhiteboardNode(type: NodeType): boolean;
+/**
+ * Get filtered categories for the current canvas type
+ */
+export declare function getCategoriesForCanvasType(canvasType: CanvasType): NodeCategory[];
+/**
+ * Create a new node from template
+ */
+export declare function createNodeFromTemplate(type: NodeType, position: Position, id?: string): WorkflowNode | null;
+/**
+ * Color preset for note nodes
+ */
+export interface NoteColorPreset {
+    name: string;
+    bg: string;
+    text: string;
+}
+/**
+ * Color preset for frame nodes
+ */
+export interface FrameColorPreset {
+    name: string;
+    bg: string;
+    border: string;
+    solid: string;
+}
+/**
+ * Predefined color presets for note nodes
+ */
+export declare const NOTE_COLOR_PRESETS: NoteColorPreset[];
+/**
+ * Predefined color presets for frame nodes
+ */
+export declare const FRAME_COLOR_PRESETS: FrameColorPreset[];
+/**
+ * Helper to check if node type is an annotation node (NOTE or FRAME)
+ */
+export declare function isAnnotationNode(type: NodeType): boolean;
+/**
+ * Helper to check if node type is a frame node
+ */
+export declare function isFrameNode(type: NodeType): boolean;
+/**
+ * Helper to check if node type is a note node
+ */
+export declare function isNoteNode(type: NodeType): boolean;
+/**
+ * Set of node types that are persistent/long-running triggers
+ */
+export declare const PERSISTENT_TRIGGER_TYPES: Set<NodeType>;
+export declare function isPersistentTriggerNode(type: NodeType): boolean;
+/**
+ * Aggregated port for collapsed frames
+ */
+export interface AggregatedPort {
+    id: string;
+    originalEdgeId: string;
+    internalNodeId: string;
+    internalPortId: string;
+    label?: string;
+    direction: 'incoming' | 'outgoing';
+}
+/**
+ * Frame resize state
+ */
+export interface FrameResizeState {
+    frameId: string;
+    handle: ResizeHandle;
+    startX: number;
+    startY: number;
+    startWidth: number;
+    startHeight: number;
+    startPosition: Position;
+}
+/**
+ * Resize handle type
+ */
+export type ResizeHandle = 'nw' | 'ne' | 'sw' | 'se' | 'n' | 's' | 'e' | 'w';
+/**
+ * Result from an undo/redo operation
+ */
+export interface UndoRedoResult {
+    success: boolean;
+    workflow?: Workflow;
+    description?: string;
+    error?: string;
+}
+/**
+ * Provider interface for undo/redo operations.
+ * Host injects an implementation so the UI never imports from the store.
+ */
+export interface UndoProvider {
+    undo(workflowId: string, workflow: Workflow): UndoRedoResult;
+    redo(workflowId: string, workflow: Workflow): UndoRedoResult;
+    canUndo(workflowId: string): boolean;
+    canRedo(workflowId: string): boolean;
+    getUndoDescription(workflowId: string): string | undefined;
+    getRedoDescription(workflowId: string): string | undefined;
+    recordAddNode(workflowId: string, node: WorkflowNode): void;
+    recordDeleteNode(workflowId: string, node: WorkflowNode, connectedEdges: WorkflowEdge[]): void;
+    recordMoveNodes(workflowId: string, moves: Array<{
+        nodeId: string;
+        oldPosition: Position;
+        newPosition: Position;
+    }>): void;
+    recordUpdateNodeConfig(workflowId: string, nodeId: string, changes: Partial<WorkflowNode>, previousState: Partial<WorkflowNode>): void;
+    recordAddEdge(workflowId: string, edge: WorkflowEdge): void;
+    recordDeleteEdge(workflowId: string, edge: WorkflowEdge): void;
+    recordBulkDelete(workflowId: string, nodes: WorkflowNode[], edges: WorkflowEdge[]): void;
+    recordPasteNodes(workflowId: string, nodes: WorkflowNode[], edges: WorkflowEdge[]): void;
+    recordDuplicateNodes(workflowId: string, nodes: WorkflowNode[], edges: WorkflowEdge[]): void;
+    flushPendingOperations(): void;
+    clearUndoHistory(workflowId: string): void;
+}
+//# sourceMappingURL=workflow-canvas.types.d.ts.map