@genfeedai/workflow-ui 0.1.0

package/dist/promptLibraryStore-BZnfmEkc.d.ts

@@ -0,0 +1,464 @@
+import * as zustand from 'zustand';
+import * as zundo from 'zundo';
+import * as _genfeedai_types from '@genfeedai/types';
+import { WorkflowNode, WorkflowEdge, NodeGroup, EdgeStyle, NodeType, WorkflowNodeData, GroupColor, WorkflowFile, ValidationResult, ProviderType, IPrompt, PromptCategory, IQueryPrompts, ICreatePrompt } from '@genfeedai/types';
+import { XYPosition, NodeChange, EdgeChange, Connection } from '@xyflow/react';
+import { P as PromptLibraryService } from './types-ipAnBzAJ.js';
+
+type ModalType = 'templates' | 'cost' | 'welcome' | 'settings' | 'promptLibrary' | 'modelBrowser' | 'nodeDetail' | 'shortcutHelp' | 'nodeSearch' | null;
+type NodeDetailTab = 'preview' | 'history';
+interface UIStore {
+    showPalette: boolean;
+    showMinimap: boolean;
+    showAIGenerator: boolean;
+    showDebugPanel: boolean;
+    selectedNodeId: string | null;
+    selectedEdgeId: string | null;
+    highlightedNodeIds: string[];
+    activeModal: ModalType;
+    nodeDetailNodeId: string | null;
+    nodeDetailActiveTab: NodeDetailTab;
+    nodeDetailStartIndex: number;
+    notifications: Notification[];
+    togglePalette: () => void;
+    toggleMinimap: () => void;
+    toggleAIGenerator: () => void;
+    toggleDebugPanel: () => void;
+    setShowDebugPanel: (show: boolean) => void;
+    selectNode: (nodeId: string | null) => void;
+    selectEdge: (edgeId: string | null) => void;
+    setHighlightedNodeIds: (ids: string[]) => void;
+    openModal: (modal: ModalType) => void;
+    closeModal: () => void;
+    openNodeDetailModal: (nodeId: string, tab?: NodeDetailTab, startIndex?: number) => void;
+    closeNodeDetailModal: () => void;
+    setNodeDetailTab: (tab: NodeDetailTab) => void;
+    addNotification: (notification: Omit<Notification, 'id'>) => void;
+    removeNotification: (id: string) => void;
+}
+interface Notification {
+    id: string;
+    type: 'success' | 'error' | 'warning' | 'info';
+    title: string;
+    message?: string;
+    duration?: number;
+}
+declare const useUIStore: zustand.UseBoundStore<zustand.StoreApi<UIStore>>;
+
+/**
+ * EditOperation type inlined from @/lib/chat/editOperations.
+ * The consuming app provides the actual applyEditOperations implementation.
+ */
+interface EditOperation {
+    type: 'add_node' | 'remove_node' | 'update_node' | 'add_edge' | 'remove_edge';
+    [key: string]: unknown;
+}
+interface WorkflowSnapshot {
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+    groups: NodeGroup[];
+    edgeStyle: EdgeStyle;
+}
+interface SnapshotSlice {
+    previousWorkflowSnapshot: WorkflowSnapshot | null;
+    manualChangeCount: number;
+    captureSnapshot: () => void;
+    revertToSnapshot: () => void;
+    clearSnapshot: () => void;
+    incrementManualChangeCount: () => void;
+    applyEditOperations: (operations: EditOperation[]) => {
+        applied: number;
+        skipped: string[];
+    };
+}
+
+interface ChatMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp: number;
+}
+interface ChatSlice {
+    chatMessages: ChatMessage[];
+    isChatOpen: boolean;
+    addChatMessage: (role: 'user' | 'assistant', content: string) => void;
+    clearChatMessages: () => void;
+    toggleChat: () => void;
+    setChatOpen: (open: boolean) => void;
+    applyChatEditOperations: (operations: EditOperation[]) => {
+        applied: number;
+        skipped: string[];
+    };
+}
+
+interface WorkflowData {
+    _id: string;
+    name: string;
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+    edgeStyle: string;
+    groups?: NodeGroup[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface WorkflowState {
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+    edgeStyle: EdgeStyle;
+    workflowName: string;
+    workflowId: string | null;
+    isDirty: boolean;
+    isSaving: boolean;
+    isLoading: boolean;
+    groups: NodeGroup[];
+    selectedNodeIds: string[];
+    viewedCommentIds: Set<string>;
+    navigationTargetId: string | null;
+}
+interface NodeActions {
+    addNode: (type: NodeType, position: XYPosition) => string;
+    addNodesAndEdges: (nodes: WorkflowNode[], edges: WorkflowEdge[]) => void;
+    updateNodeData: <T extends WorkflowNodeData>(nodeId: string, data: Partial<T>) => void;
+    removeNode: (nodeId: string) => void;
+    duplicateNode: (nodeId: string) => string | null;
+    propagateOutputsDownstream: (sourceNodeId: string, outputValue?: string) => void;
+}
+interface ReactFlowActions {
+    onNodesChange: (changes: NodeChange<WorkflowNode>[]) => void;
+    onEdgesChange: (changes: EdgeChange<WorkflowEdge>[]) => void;
+    onConnect: (connection: Connection) => void;
+}
+interface EdgeActions {
+    removeEdge: (edgeId: string) => void;
+    setEdgeStyle: (style: EdgeStyle) => void;
+    toggleEdgePause: (edgeId: string) => void;
+}
+interface LockingActions {
+    _setNodeLockState: (predicate: (nodeId: string) => boolean, lock: boolean) => void;
+    toggleNodeLock: (nodeId: string) => void;
+    lockNode: (nodeId: string) => void;
+    unlockNode: (nodeId: string) => void;
+    lockMultipleNodes: (nodeIds: string[]) => void;
+    unlockMultipleNodes: (nodeIds: string[]) => void;
+    unlockAllNodes: () => void;
+    isNodeLocked: (nodeId: string) => boolean;
+}
+interface GroupActions {
+    createGroup: (nodeIds: string[], name?: string) => string;
+    deleteGroup: (groupId: string) => void;
+    addToGroup: (groupId: string, nodeIds: string[]) => void;
+    removeFromGroup: (groupId: string, nodeIds: string[]) => void;
+    toggleGroupLock: (groupId: string) => void;
+    renameGroup: (groupId: string, name: string) => void;
+    setGroupColor: (groupId: string, color: GroupColor) => void;
+    getGroupByNodeId: (nodeId: string) => NodeGroup | undefined;
+    getGroupById: (groupId: string) => NodeGroup | undefined;
+}
+interface SelectionActions {
+    setSelectedNodeIds: (nodeIds: string[]) => void;
+    addToSelection: (nodeId: string) => void;
+    removeFromSelection: (nodeId: string) => void;
+    clearSelection: () => void;
+}
+interface LocalWorkflowActions {
+    loadWorkflow: (workflow: WorkflowFile) => void;
+    clearWorkflow: () => void;
+    exportWorkflow: () => WorkflowFile;
+}
+interface ApiActions {
+    saveWorkflow: (signal?: AbortSignal) => Promise<WorkflowData>;
+    loadWorkflowById: (id: string, signal?: AbortSignal) => Promise<void>;
+    listWorkflows: (signal?: AbortSignal) => Promise<WorkflowData[]>;
+    deleteWorkflow: (id: string, signal?: AbortSignal) => Promise<void>;
+    duplicateWorkflowApi: (id: string, signal?: AbortSignal) => Promise<WorkflowData>;
+    createNewWorkflow: (signal?: AbortSignal) => Promise<string>;
+    setWorkflowName: (name: string) => void;
+}
+interface HelperActions$1 {
+    getNodeById: (id: string) => WorkflowNode | undefined;
+    getConnectedInputs: (nodeId: string) => Map<string, string | string[]>;
+    getConnectedNodeIds: (nodeIds: string[]) => string[];
+    validateWorkflow: () => ValidationResult;
+    isValidConnection: (connection: Connection) => boolean;
+    findCompatibleHandle: (sourceNodeId: string, sourceHandleId: string | null, targetNodeId: string) => string | null;
+    setDirty: (dirty: boolean) => void;
+}
+interface CommentNavigationActions {
+    getNodesWithComments: () => WorkflowNode[];
+    markCommentViewed: (nodeId: string) => void;
+    setNavigationTarget: (nodeId: string | null) => void;
+    getUnviewedCommentCount: () => number;
+}
+interface WorkflowStore extends WorkflowState, NodeActions, ReactFlowActions, EdgeActions, LockingActions, GroupActions, SelectionActions, LocalWorkflowActions, ApiActions, HelperActions$1, CommentNavigationActions, SnapshotSlice, ChatSlice {
+}
+
+declare const useWorkflowStore: zustand.UseBoundStore<Omit<zustand.StoreApi<WorkflowStore>, "temporal"> & {
+    temporal: zustand.StoreApi<zundo.TemporalState<{
+        nodes: _genfeedai_types.WorkflowNode[];
+        edges: _genfeedai_types.WorkflowEdge[];
+        groups: _genfeedai_types.NodeGroup[];
+    }>>;
+}>;
+
+interface DebugPayload {
+    nodeId: string;
+    nodeName: string;
+    nodeType: string;
+    model: string;
+    input: Record<string, unknown>;
+    timestamp: string;
+}
+interface Job {
+    nodeId: string;
+    predictionId: string;
+    status: 'pending' | 'processing' | 'succeeded' | 'failed' | 'canceled';
+    progress: number;
+    output: unknown | null;
+    error: string | null;
+    createdAt: string;
+}
+interface NodeExecution {
+    executionId: string;
+    nodeIds: string[];
+    eventSource: EventSource;
+}
+interface ExecutionState {
+    isRunning: boolean;
+    executionId: string | null;
+    currentNodeId: string | null;
+    /** Node IDs being executed (for partial execution). Empty = all nodes */
+    executingNodeIds: string[];
+    validationErrors: ValidationResult | null;
+    eventSource: EventSource | null;
+    lastFailedNodeId: string | null;
+    pausedAtNodeId: string | null;
+    jobs: Map<string, Job>;
+    estimatedCost: number;
+    actualCost: number;
+    debugPayloads: DebugPayload[];
+    /** Independent per-node executions (Generate button clicks) */
+    activeNodeExecutions: Map<string, NodeExecution>;
+}
+interface ExecutionActions {
+    executeWorkflow: () => Promise<void>;
+    executeSelectedNodes: () => Promise<void>;
+    executeNode: (nodeId: string) => Promise<void>;
+    resumeFromFailed: () => Promise<void>;
+    stopExecution: () => void;
+    stopNodeExecution: (nodeId: string) => void;
+    isNodeExecuting: (nodeId: string) => boolean;
+    clearValidationErrors: () => void;
+}
+interface JobActions {
+    addJob: (nodeId: string, predictionId: string) => void;
+    updateJob: (predictionId: string, updates: Partial<Job>) => void;
+    getJobByNodeId: (nodeId: string) => Job | undefined;
+}
+interface HelperActions {
+    resetExecution: () => void;
+    canResumeFromFailed: () => boolean;
+    setEstimatedCost: (cost: number) => void;
+    addDebugPayload: (payload: DebugPayload) => void;
+    clearDebugPayloads: () => void;
+}
+interface ExecutionStore extends ExecutionState, ExecutionActions, JobActions, HelperActions {
+}
+
+/**
+ * Execution Store
+ *
+ * Manages workflow execution state including jobs, validation, and SSE subscriptions.
+ * Split into slices for maintainability:
+ *
+ * - executionSlice: Core execution operations (run, stop, resume)
+ * - jobSlice: Job tracking and management
+ */
+declare const useExecutionStore: zustand.UseBoundStore<zustand.StoreApi<ExecutionStore>>;
+
+interface ProviderConfig {
+    apiKey: string | null;
+    enabled: boolean;
+}
+interface ProviderSettings {
+    replicate: ProviderConfig;
+    fal: ProviderConfig;
+    huggingface: ProviderConfig;
+    'genfeed-ai': ProviderConfig;
+}
+interface DefaultModelSettings {
+    imageModel: string;
+    imageProvider: ProviderType;
+    videoModel: string;
+    videoProvider: ProviderType;
+}
+interface RecentModel {
+    id: string;
+    displayName: string;
+    provider: ProviderType;
+    timestamp: number;
+}
+interface SettingsStore {
+    providers: ProviderSettings;
+    defaults: DefaultModelSettings;
+    edgeStyle: EdgeStyle;
+    showMinimap: boolean;
+    autoSaveEnabled: boolean;
+    recentModels: RecentModel[];
+    hasSeenWelcome: boolean;
+    debugMode: boolean;
+    toggleAutoSave: () => void;
+    setDebugMode: (enabled: boolean) => void;
+    setProviderKey: (provider: ProviderType, key: string | null) => void;
+    setProviderEnabled: (provider: ProviderType, enabled: boolean) => void;
+    setDefaultModel: (type: 'image' | 'video', model: string, provider: ProviderType) => void;
+    setEdgeStyle: (style: EdgeStyle) => void;
+    setShowMinimap: (show: boolean) => void;
+    addRecentModel: (model: Omit<RecentModel, 'timestamp'>) => void;
+    clearProviderKey: (provider: ProviderType) => void;
+    clearAllKeys: () => void;
+    setHasSeenWelcome: (seen: boolean) => void;
+    isProviderConfigured: (provider: ProviderType) => boolean;
+    getProviderHeader: (provider: ProviderType) => Record<string, string>;
+    isSyncing: boolean;
+    syncFromServer: () => Promise<void>;
+    syncToServer: () => Promise<void>;
+}
+declare const useSettingsStore: zustand.UseBoundStore<zustand.StoreApi<SettingsStore>>;
+declare const PROVIDER_INFO: Record<ProviderType, {
+    name: string;
+    description: string;
+    docsUrl: string;
+}>;
+
+interface PromptEditorStore {
+    isOpen: boolean;
+    nodeId: string | null;
+    prompt: string;
+    fontSize: number;
+    openEditor: (nodeId: string, prompt: string) => void;
+    closeEditor: () => void;
+    setPrompt: (prompt: string) => void;
+    setFontSize: (size: number) => void;
+    saveAndClose: () => {
+        nodeId: string;
+        prompt: string;
+    } | null;
+}
+declare const usePromptEditorStore: zustand.UseBoundStore<zustand.StoreApi<PromptEditorStore>>;
+
+type AnnotationTool = 'select' | 'rectangle' | 'circle' | 'arrow' | 'freehand' | 'text';
+interface ToolOptions {
+    strokeColor: string;
+    strokeWidth: number;
+    fillColor: string | null;
+    fontSize: number;
+}
+interface BaseShape {
+    id: string;
+    type: AnnotationTool;
+    strokeColor: string;
+    strokeWidth: number;
+    fillColor: string | null;
+}
+interface RectangleShape extends BaseShape {
+    type: 'rectangle';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface CircleShape extends BaseShape {
+    type: 'circle';
+    x: number;
+    y: number;
+    radius: number;
+}
+interface ArrowShape extends BaseShape {
+    type: 'arrow';
+    points: number[];
+}
+interface FreehandShape extends BaseShape {
+    type: 'freehand';
+    points: number[];
+}
+interface TextShape extends BaseShape {
+    type: 'text';
+    x: number;
+    y: number;
+    text: string;
+    fontSize: number;
+}
+type AnnotationShape = RectangleShape | CircleShape | ArrowShape | FreehandShape | TextShape;
+interface AnnotationStore {
+    isOpen: boolean;
+    nodeId: string | null;
+    sourceImage: string | null;
+    shapes: AnnotationShape[];
+    selectedShapeId: string | null;
+    currentTool: AnnotationTool;
+    toolOptions: ToolOptions;
+    history: AnnotationShape[][];
+    historyIndex: number;
+    isDrawing: boolean;
+    drawingShape: Partial<AnnotationShape> | null;
+    openAnnotation: (nodeId: string, image: string, existingShapes?: AnnotationShape[]) => void;
+    closeAnnotation: () => void;
+    saveAndClose: () => {
+        nodeId: string;
+        shapes: AnnotationShape[];
+    } | null;
+    addShape: (shape: AnnotationShape) => void;
+    updateShape: (id: string, updates: Partial<AnnotationShape>) => void;
+    deleteShape: (id: string) => void;
+    selectShape: (id: string | null) => void;
+    clearShapes: () => void;
+    setTool: (tool: AnnotationTool) => void;
+    setToolOptions: (options: Partial<ToolOptions>) => void;
+    startDrawing: (shape: Partial<AnnotationShape>) => void;
+    updateDrawing: (updates: Partial<AnnotationShape>) => void;
+    finishDrawing: () => void;
+    cancelDrawing: () => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+}
+declare const useAnnotationStore: zustand.UseBoundStore<zustand.StoreApi<AnnotationStore>>;
+
+/**
+ * Configure the prompt library store with an API service.
+ * Called by WorkflowUIProvider when a promptLibrary service is provided.
+ *
+ * This pattern is used because Zustand stores exist outside the React tree
+ * and cannot use useContext directly.
+ */
+declare function configurePromptLibrary(api: PromptLibraryService): void;
+interface PromptLibraryStore {
+    items: IPrompt[];
+    featuredItems: IPrompt[];
+    selectedItem: IPrompt | null;
+    isLoading: boolean;
+    error: string | null;
+    searchQuery: string;
+    categoryFilter: PromptCategory | null;
+    isPickerOpen: boolean;
+    isCreateModalOpen: boolean;
+    editingItem: IPrompt | null;
+    setSearchQuery: (query: string) => void;
+    setCategoryFilter: (category: PromptCategory | null) => void;
+    setSelectedItem: (item: IPrompt | null) => void;
+    openPicker: () => void;
+    closePicker: () => void;
+    openCreateModal: (editItem?: IPrompt) => void;
+    closeCreateModal: () => void;
+    loadItems: (query?: IQueryPrompts, signal?: AbortSignal) => Promise<void>;
+    loadFeatured: (signal?: AbortSignal) => Promise<void>;
+    createItem: (data: ICreatePrompt, signal?: AbortSignal) => Promise<IPrompt>;
+    updateItem: (id: string, data: Partial<ICreatePrompt>, signal?: AbortSignal) => Promise<IPrompt>;
+    deleteItem: (id: string, signal?: AbortSignal) => Promise<void>;
+    duplicateItem: (id: string, signal?: AbortSignal) => Promise<IPrompt>;
+    recordItemUsage: (id: string, signal?: AbortSignal) => Promise<IPrompt>;
+}
+declare const usePromptLibraryStore: zustand.UseBoundStore<zustand.StoreApi<PromptLibraryStore>>;
+
+export { type AnnotationTool as A, type BaseShape as B, type CircleShape as C, type DebugPayload as D, type ExecutionStore as E, type FreehandShape as F, type Job as J, type ModalType as M, type NodeDetailTab as N, type ProviderConfig as P, type RecentModel as R, type ToolOptions as T, type WorkflowStore as W, useWorkflowStore as a, useExecutionStore as b, useSettingsStore as c, usePromptEditorStore as d, useAnnotationStore as e, usePromptLibraryStore as f, configurePromptLibrary as g, type WorkflowData as h, type WorkflowState as i, type ProviderSettings as j, type DefaultModelSettings as k, PROVIDER_INFO as l, type RectangleShape as m, type ArrowShape as n, type TextShape as o, type AnnotationShape as p, useUIStore as u };