@fluxo-dev/shell-workflow 26.1.1 → 26.1.3

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@fluxo-dev/shell-workflow",
-  "version": "26.1.1",
+  "version": "26.1.3",
   "peerDependencies": {
     "react": "^18.3.1",
     "@mantine/core": "^7.12.2",
     "react-router-dom": "^6.11.2",
     "react-redux": "^8.0.5",
     "@reduxjs/toolkit": "^1.9.1",
-    "@fluxo-dev/api-client-base": "^26.1.1",
-    "@fluxo-dev/state": "^26.1.1",
-    "@fluxo-dev/ui-components": "^26.1.1"
+    "@fluxo-dev/api-client-base": "^26.1.3",
+    "@fluxo-dev/state": "^26.1.3",
+    "@fluxo-dev/ui-components": "^26.1.3"
   },
   "module": "./index.esm.js",
   "type": "module",

package/src/index.d.ts

@@ -1,2 +1,6 @@
-export * from './lib/designer/workflow-designer';
+export * from './lib/workflow/browse/workflow-browse';
+export * from './lib/workflow/browse/workflow-executions-panel';
+export * from './lib/workflow/designer-v2';
+export * from './lib/etl/browse';
+export * from './lib/etl/designer';
 export * from './lib/fluxo-module';

package/src/lib/etl/browse/etl-browse.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { ShellPageRef } from '@fluxo-dev/ui-components';
+export interface EtlBrowseProps {
+    shellPageRef: React.RefObject<ShellPageRef>;
+}
+export declare function EtlBrowse({ shellPageRef }: EtlBrowseProps): import("react/jsx-runtime").JSX.Element;

package/src/lib/etl/browse/index.d.ts

@@ -0,0 +1,2 @@
+export { EtlBrowse } from './etl-browse';
+export type { EtlBrowseProps } from './etl-browse';

package/src/lib/etl/components/nodes/EtlBlockNode.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { NodeProps } from '@xyflow/react';
+export declare const EtlBlockNode: React.MemoExoticComponent<({ data, selected, id }: NodeProps) => import("react/jsx-runtime").JSX.Element>;

package/src/lib/etl/components/nodes/index.d.ts

@@ -0,0 +1 @@
+export * from './EtlBlockNode';

package/src/lib/etl/components/panels/BlockConfigPanel.d.ts

@@ -0,0 +1,10 @@
+import { Node } from '@xyflow/react';
+import { EtlNodeData } from '../../types';
+interface BlockConfigPanelProps {
+    node: Node<EtlNodeData>;
+    onClose: () => void;
+    onSave: (nodeId: string, config: Record<string, unknown>) => void;
+    readOnly?: boolean;
+}
+export declare function BlockConfigPanel({ node, onClose, onSave, readOnly }: BlockConfigPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/src/lib/etl/components/panels/BlocksPanel.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { BlockDescriptor, BlocksByCategory } from '../../types';
+interface BlocksPanelProps {
+    blocksByCategory: BlocksByCategory;
+    onBlockDragStart: (event: React.DragEvent, blockType: string, descriptor: BlockDescriptor) => void;
+}
+export declare function BlocksPanel({ blocksByCategory, onBlockDragStart }: BlocksPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/src/lib/etl/components/panels/PreviewDataPanel.d.ts

@@ -0,0 +1,8 @@
+import { PreviewItem } from '../../types';
+export interface PreviewDataPanelProps {
+    opened: boolean;
+    onClose: () => void;
+    nodeLabel: string;
+    previewItemsByChannel?: Record<string, PreviewItem[]>;
+}
+export declare function PreviewDataPanel({ opened, onClose, nodeLabel, previewItemsByChannel, }: PreviewDataPanelProps): import("react/jsx-runtime").JSX.Element | null;

package/src/lib/etl/components/panels/index.d.ts

@@ -0,0 +1,3 @@
+export * from './BlocksPanel';
+export * from './BlockConfigPanel';
+export * from './PreviewDataPanel';

package/src/lib/etl/constants/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ETL Designer Constants
+ */
+export declare const ETL_COLORS: {
+    sources: string;
+    transforms: string;
+    enrichers: string;
+    sinks: string;
+    default: string;
+    deadletter: string;
+    input: string;
+    success: string;
+    error: string;
+    warning: string;
+    info: string;
+};
+export declare const BLOCK_CATEGORIES: string[];
+export declare const DEFAULT_PIPELINE_SETTINGS: {
+    maxDegreeOfParallelism: number;
+    boundedCapacity: number;
+    cancellationTimeoutSeconds: number;
+};

package/src/lib/etl/designer/EtlDesignerContext.d.ts

@@ -0,0 +1,14 @@
+import { NodeDebugRuntime, PipelineDebugRuntime } from '../types';
+export interface EtlDesignerContextValue {
+    [key: string]: unknown;
+    onDuplicateNode: (nodeId: string) => void;
+    getNodeDebugRuntime: (nodeId: string) => NodeDebugRuntime | undefined;
+    pipelineDebug: PipelineDebugRuntime;
+    isDebugActive: boolean;
+    startLiveDebug: () => Promise<void>;
+    stopLiveDebug: () => Promise<void>;
+    openPreviewPanel: (nodeId: string) => void;
+}
+export declare const EtlDesignerContext: import("react").Context<EtlDesignerContextValue>;
+export declare function buildEtlDesignerContextValue(value: EtlDesignerContextValue): EtlDesignerContextValue;
+export declare function useEtlDesignerContext(): EtlDesignerContextValue;

package/src/lib/etl/designer/etl-designer.d.ts

@@ -0,0 +1,7 @@
+import '@xyflow/react/dist/style.css';
+export interface EtlDesignerProps {
+    pipelineId?: string;
+    onClose: () => void;
+    onSave?: () => void;
+}
+export declare function EtlDesigner({ pipelineId, onClose, onSave }: EtlDesignerProps): import("react/jsx-runtime").JSX.Element;

package/src/lib/etl/designer/index.d.ts

@@ -0,0 +1 @@
+export * from './etl-designer';

package/src/lib/etl/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export * from './useBlockDefinitions';
+export * from './usePipelineState';
+export * from './usePipelineActions';
+export * from './useNodeOperations';
+export * from './useExecutionHistory';
+export * from './usePipelineLiveDebug';

package/src/lib/etl/hooks/useBlockDefinitions.d.ts

@@ -0,0 +1,12 @@
+import { BlockDescriptor, BlocksByCategory } from '../types';
+/**
+ * Hook to load block definitions from the ETL API
+ */
+export declare function useBlockDefinitions(): {
+    blocks: BlockDescriptor[];
+    blocksByCategory: BlocksByCategory;
+    blockDescriptors: Map<string, BlockDescriptor>;
+    loading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+};

package/src/lib/etl/hooks/useExecutionHistory.d.ts

@@ -0,0 +1,13 @@
+import { PipelineExecutionHistoryItem, PipelineListItem } from '../types';
+/**
+ * Hook to manage pipeline execution history
+ */
+export declare function useExecutionHistory(): {
+    executions: PipelineExecutionHistoryItem[];
+    runningExecutionIds: Set<string>;
+    executionsLoading: boolean;
+    selectedPipelineForHistory: PipelineListItem | null;
+    setSelectedPipelineForHistory: import("react").Dispatch<import("react").SetStateAction<PipelineListItem | null>>;
+    loadPipelineHistory: (pipelineId: string, pipelineName?: string) => Promise<void>;
+    resetHistory: () => void;
+};

package/src/lib/etl/hooks/useNodeOperations.d.ts

@@ -0,0 +1,15 @@
+import { Edge, Node } from '@xyflow/react';
+import { EtlNodeData, BlockDescriptor } from '../types';
+/**
+ * Hook for node operations (add, update, delete)
+ */
+export declare function useNodeOperations(nodes: Node<EtlNodeData>[], setNodes: (nodes: Node<EtlNodeData>[] | ((nodes: Node<EtlNodeData>[]) => Node<EtlNodeData>[])) => void, setEdges: (edges: Edge[] | ((edges: Edge[]) => Edge[])) => void): {
+    addBlockNode: (blockType: string, descriptor: BlockDescriptor, position: {
+        x: number;
+        y: number;
+    }) => Node<EtlNodeData>;
+    updateNodeData: (nodeId: string, updates: Partial<EtlNodeData>) => void;
+    updateNodeConfig: (nodeId: string, config: Record<string, unknown>) => void;
+    deleteNode: (nodeId: string) => void;
+    duplicateNode: (nodeId: string) => void;
+};

package/src/lib/etl/hooks/usePipelineActions.d.ts

@@ -0,0 +1,25 @@
+import { Node, Edge } from '@xyflow/react';
+import { EtlNodeData, PipelineMetadata, ValidationResult, PipelineResult } from '../types';
+/**
+ * Hook for pipeline actions (save, validate, execute)
+ */
+export declare function usePipelineActions(_pipelineId?: string): {
+    savePipeline: (data: {
+        nodes: Node<EtlNodeData>[];
+        edges: Edge[];
+        metadata: PipelineMetadata;
+    }) => Promise<import("@fluxo-dev/api-client-base").SavePipelineResponse>;
+    validatePipeline: (data: {
+        nodes: Node<EtlNodeData>[];
+        edges: Edge[];
+        metadata: PipelineMetadata;
+    }) => Promise<ValidationResult>;
+    executePipeline: (data: {
+        nodes: Node<EtlNodeData>[];
+        edges: Edge[];
+        metadata: PipelineMetadata;
+    }, dryRun?: boolean) => Promise<PipelineResult>;
+    loading: boolean;
+    validating: boolean;
+    executing: boolean;
+};

package/src/lib/etl/hooks/usePipelineLiveDebug.d.ts

@@ -0,0 +1,20 @@
+import { Edge, Node } from '@xyflow/react';
+import { EtlNodeData, NodeDebugRuntime, PipelineDebugRuntime, PipelineMetadata } from '../types';
+type LocalEdgeDebugRuntime = {
+    edgeId: string;
+    sourceNodeId: string;
+    targetNodeId: string;
+    status: 'idle' | 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+};
+export declare function usePipelineLiveDebug(nodes: Node<EtlNodeData>[], edges: Edge[], metadata: PipelineMetadata): {
+    pipelineDebug: PipelineDebugRuntime;
+    nodeRuntimeById: Record<string, NodeDebugRuntime>;
+    edgeRuntimeById: Record<string, LocalEdgeDebugRuntime>;
+    getNodeDebugRuntime: (nodeId: string) => NodeDebugRuntime;
+    getEdgeDebugRuntime: (edgeId: string) => LocalEdgeDebugRuntime;
+    startLiveDebug: () => Promise<void>;
+    stopLiveDebug: () => Promise<void>;
+    resetDebugState: () => void;
+    isDebugActive: boolean;
+};
+export {};

package/src/lib/etl/hooks/usePipelineState.d.ts

@@ -0,0 +1,16 @@
+import { Edge, Node } from '@xyflow/react';
+import { EtlNodeData, PipelineMetadata } from '../types';
+/**
+ * Hook to manage pipeline state (nodes, edges, metadata)
+ */
+export declare function usePipelineState(_pipelineId?: string): {
+    nodes: Node<EtlNodeData>[];
+    edges: Edge[];
+    metadata: PipelineMetadata;
+    setNodes: import("react").Dispatch<import("react").SetStateAction<Node<EtlNodeData>[]>>;
+    setEdges: import("react").Dispatch<import("react").SetStateAction<Edge[]>>;
+    setMetadata: import("react").Dispatch<import("react").SetStateAction<PipelineMetadata>>;
+    onNodesChange: import("@xyflow/react").OnNodesChange<Node<EtlNodeData>>;
+    onEdgesChange: import("@xyflow/react").OnEdgesChange<Edge>;
+    resetPipeline: () => void;
+};

package/src/lib/etl/services/etl-debug-hub.service.d.ts

@@ -0,0 +1,13 @@
+import { HubConnectionState } from '@microsoft/signalr';
+export declare class EtlDebugHubService {
+    private connection;
+    private subscribedExecutionId;
+    private eventHandlers;
+    ensureConnected(): Promise<void>;
+    subscribeToPipeline(executionId: string): Promise<void>;
+    on<T>(eventName: string, handler: (payload: T) => void): void;
+    off(eventName: string): void;
+    get state(): HubConnectionState;
+    stop(): Promise<void>;
+    private reattachHandlers;
+}

package/src/lib/etl/types/etl-block.types.d.ts

@@ -0,0 +1,2 @@
+export { BlockConfigFieldType, DynamicPortType, } from '@fluxo-dev/api-client-base';
+export type { BlockDescriptor, BlockUiDescriptor, BlockPortDescriptor, PortVisibilityCondition, BlockConfigField, SelectOption, FieldValidation, BlocksByCategory, DynamicPortsDescriptor, } from '@fluxo-dev/api-client-base';

package/src/lib/etl/types/etl-config-field.types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Configuration field types for ETL blocks
+ */
+export interface ConfigFieldProps {
+    field: any;
+    value: any;
+    onChange: (value: any) => void;
+    error?: string;
+}

package/src/lib/etl/types/etl-live-debug.types.d.ts

@@ -0,0 +1,56 @@
+import { HubConnectionState } from '@microsoft/signalr';
+import type { BlockMetrics } from './etl-pipeline.types';
+export declare enum PipelineEventType {
+    NodeStarted = 0,
+    NodeCompleted = 1,
+    NodeFailed = 2,
+    ItemProcessed = 3,
+    ItemDeadLettered = 4,
+    ItemSkipped = 5,
+    PipelineStarted = 6,
+    PipelineCompleted = 7,
+    PipelineFailed = 8,
+    PipelineCancelled = 9
+}
+export interface PipelineEvent {
+    pipelineExecutionId: string;
+    nodeId: string;
+    nodeType: string;
+    type: PipelineEventType;
+    timestamp: string;
+    payload: Record<string, unknown>;
+}
+export type LiveBlockMetrics = BlockMetrics;
+export interface MetricsSnapshot {
+    executionId: string;
+    timestamp: string;
+    metrics: LiveBlockMetrics[];
+}
+export type DebugNodeStatus = 'idle' | 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+export type DebugEdgeStatus = 'idle' | 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+export type DebugPipelineStatus = 'idle' | 'connecting' | 'subscribed' | 'running' | 'completed' | 'failed' | 'cancelled';
+export interface NodeDebugRuntime {
+    nodeId: string;
+    status: DebugNodeStatus;
+    lastEventType?: PipelineEventType;
+    updatedAt?: string;
+    metrics?: LiveBlockMetrics;
+    error?: string;
+}
+export interface EdgeDebugRuntime {
+    edgeId: string;
+    sourceNodeId: string;
+    targetNodeId: string;
+    status: DebugEdgeStatus;
+}
+export interface PipelineDebugRuntime {
+    executionId: string | null;
+    status: DebugPipelineStatus;
+    connectionState: HubConnectionState;
+    isStarting: boolean;
+    isStopping: boolean;
+    error?: string;
+    startedAt?: string;
+    updatedAt?: string;
+    completedAt?: string;
+}

package/src/lib/etl/types/etl-pipeline.types.d.ts

@@ -0,0 +1,243 @@
+import { Node, Edge } from '@xyflow/react';
+import type { BlockDescriptor, BlockPortDescriptor } from './etl-block.types';
+export interface PipelineDefinition {
+    $schema?: string;
+    id?: string;
+    name: string;
+    description?: string;
+    version?: string;
+    settings?: PipelineSettings;
+    variables?: Record<string, unknown>;
+    nodes: NodeDefinition[];
+    edges: EdgeDefinition[];
+}
+export interface PipelineSettings {
+    maxDegreeOfParallelism?: number;
+    boundedCapacity?: number;
+    cancellationTimeoutSeconds?: number;
+}
+export interface NodeDefinition {
+    id: string;
+    type: string;
+    pattern?: string;
+    label?: string;
+    config: Record<string, unknown>;
+    position?: {
+        x: number;
+        y: number;
+    };
+}
+export interface EdgeDefinition {
+    id?: string;
+    from: string;
+    to: string;
+    channel?: string;
+    sourceHandle?: string;
+    targetHandle?: string;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationError[];
+}
+export interface ValidationError {
+    code: string;
+    message: string;
+    nodeId?: string;
+    fieldKey?: string;
+    nodeIds?: string[];
+    severity: 'Error' | 'Warning';
+}
+export interface PipelineResult {
+    executionId: string;
+    status: PipelineStatus | number;
+    duration: string;
+    totalItemsProcessed: number;
+    totalItemsDeadLettered: number;
+    totalItemsSkipped: number;
+    startTime: string;
+    endTime: string;
+    blockMetrics: BlockMetrics[];
+    errorMessage?: string;
+}
+export declare enum PipelineStatus {
+    Pending = 0,
+    Running = 1,
+    Paused = 2,
+    Completed = 3,
+    Failed = 4,
+    Cancelled = 5
+}
+export declare enum NodeExecutionState {
+    Pending = 0,
+    Running = 1,
+    Completed = 2,
+    Failed = 3,
+    Cancelled = 4
+}
+export interface BlockMetrics {
+    nodeId: string;
+    nodeType: string;
+    itemsIn: number;
+    itemsOut: number;
+    itemsOutByChannel: Record<string, number>;
+    itemsDeadLettered: number;
+    itemsSkipped: number;
+    totalDuration: string;
+    throughput: number;
+    averageItemDuration: string;
+    minItemDuration: string;
+    maxItemDuration: string;
+    nodeState: NodeExecutionState | number | string;
+    hasFailed: boolean;
+    failureReason?: string;
+    previewItemsByChannel?: Record<string, PreviewItem[]>;
+}
+export interface PreviewItem {
+    [key: string]: unknown;
+    _truncated?: boolean;
+    _originalSize?: number;
+}
+export interface SavePipelineRequest {
+    id?: string;
+    name: string;
+    description?: string;
+    category?: string;
+    definitionJson: string;
+    isActive: boolean;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface SavePipelineResponse {
+    id: string;
+    name: string;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface PipelineListItem {
+    id: string;
+    name: string;
+    description?: string;
+    version: number;
+    category?: string;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+    lastExecutedAt?: string;
+    lastExecutionStatus?: PipelineStatus;
+    executionCount: number;
+    successRate: number;
+    tags?: string[];
+}
+export interface PipelineDetails {
+    id: string;
+    name: string;
+    description?: string;
+    version: number;
+    definitionJson: string;
+    category?: string;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+    createdBy?: string;
+    updatedBy?: string;
+    lastExecutedAt?: string;
+    lastExecutionStatus?: PipelineStatus;
+    executionCount: number;
+    successCount: number;
+    failureCount: number;
+    successRate: number;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface ExecuteSavedPipelineRequest {
+    pipelineId: string;
+    dryRun?: boolean;
+    variableOverrides?: Record<string, unknown>;
+}
+export interface PipelineExecutionHistoryItem {
+    id: string;
+    executionId: string;
+    pipelineId: string;
+    pipelineName: string;
+    pipelineVersion: string;
+    status: PipelineStatus;
+    startTime: string;
+    endTime?: string;
+    formattedDuration?: string;
+    totalItemsProcessed: number;
+    totalItemsDeadLettered: number;
+    totalItemsSkipped: number;
+    successRate: number;
+    errorMessage?: string;
+    executedBy?: string;
+    isDryRun: boolean;
+    serverHostname?: string;
+}
+export interface PipelineExecutionDetails extends PipelineExecutionHistoryItem {
+    errorStackTrace?: string;
+    blockMetricsJson?: string;
+    pipelineDefinitionSnapshot?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RunningExecutionItem {
+    executionId: string;
+    startTime: string;
+    elapsedTime: string;
+}
+export interface StopExecutionResponse {
+    success: boolean;
+    message: string;
+}
+export interface ValidatePipelineRequest {
+    definitionJson: string;
+}
+export interface ExecutePipelineRequest {
+    executionId: string;
+    definitionJson: string;
+    dryRun?: boolean;
+    isDebugMode: boolean;
+    maxPreviewItems: number;
+}
+/**
+ * Node data for ReactFlow ETL nodes
+ */
+export interface EtlNodeData {
+    [key: string]: unknown;
+    label: string;
+    blockType: string;
+    descriptor?: BlockDescriptor;
+    config: Record<string, unknown>;
+    inputs: BlockPortDescriptor[];
+    outputs: BlockPortDescriptor[];
+}
+/**
+ * Pipeline metadata used by the designer UI
+ */
+export interface PipelineMetadata {
+    name: string;
+    description: string;
+    category: string;
+    pipelineId?: string;
+    isActive?: boolean;
+    tags?: string[];
+    customMetadata?: Record<string, unknown>;
+    maxPreviewItems?: number;
+}
+/**
+ * Complete pipeline state
+ */
+export interface PipelineState {
+    nodes: Node<EtlNodeData>[];
+    edges: Edge[];
+    metadata: PipelineMetadata;
+}
+/**
+ * Pipeline save data
+ */
+export interface PipelineSaveData {
+    nodes: Node<EtlNodeData>[];
+    edges: Edge[];
+    metadata: PipelineMetadata;
+}

package/src/lib/etl/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './etl-block.types';
+export * from './etl-pipeline.types';
+export * from './etl-live-debug.types';
+export * from './etl-config-field.types';

package/src/lib/etl/utils/config-field-utils.d.ts

@@ -0,0 +1,26 @@
+import { BlockConfigField } from '../types';
+/**
+ * Determina se un campo deve essere visibile in base alla condizione visibleWhen.
+ * Se visibleWhen non è definito, il campo è sempre visibile.
+ *
+ * @param field - Il campo da valutare
+ * @param config - La configurazione corrente del blocco
+ * @returns true se il campo deve essere visibile, false altrimenti
+ */
+export declare function isFieldVisible(field: BlockConfigField, config: Record<string, unknown>): boolean;
+/**
+ * Filtra i campi restituendo solo quelli visibili in base alla configurazione corrente.
+ *
+ * @param fields - Array di campi da filtrare
+ * @param config - La configurazione corrente del blocco
+ * @returns Array di campi visibili
+ */
+export declare function getVisibleFields(fields: BlockConfigField[], config: Record<string, unknown>): BlockConfigField[];
+/**
+ * Filtra i campi obbligatori restituendo solo quelli visibili in base alla configurazione corrente.
+ *
+ * @param fields - Array di campi da filtrare
+ * @param config - La configurazione corrente del blocco
+ * @returns Array di campi obbligatori e visibili
+ */
+export declare function getVisibleRequiredFields(fields: BlockConfigField[], config: Record<string, unknown>): BlockConfigField[];

package/src/lib/etl/utils/dynamic-ports.d.ts

@@ -0,0 +1,12 @@
+import { BlockDescriptor, BlockPortDescriptor, DynamicPortsDescriptor } from '../types';
+/**
+ * Genera porte dinamiche basate sul descriptor e sulla configurazione del blocco.
+ *
+ * @param descriptor Descriptor delle porte dinamiche
+ * @param config Configurazione corrente del blocco
+ * @returns Array di porte generate dinamicamente
+ */
+export declare function generateDynamicPorts(descriptor: DynamicPortsDescriptor | undefined, config: Record<string, unknown>): BlockPortDescriptor[];
+export declare function getEffectiveInputPorts(descriptor: BlockDescriptor | undefined, config: Record<string, unknown>): BlockPortDescriptor[];
+export declare function getEffectiveOutputPorts(descriptor: BlockDescriptor | undefined, config: Record<string, unknown>): BlockPortDescriptor[];
+export declare function isPortVisible(port: BlockPortDescriptor, config: Record<string, unknown>): boolean;

package/src/lib/etl/utils/icon-mapper.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { IconProps } from '@tabler/icons-react';
+type TablerIcon = React.ForwardRefExoticComponent<IconProps & React.RefAttributes<SVGSVGElement>>;
+/**
+ * Risolve dinamicamente un'icona Tabler dal nome stringa inviato dal server.
+ * Fallback: IconBox
+ *
+ * Input supportati:
+ *   "database" | "Database" | "IconDatabase" | "icon-database" | "icon_database"
+ */
+export declare function resolveBlockIcon(iconName: string | undefined): TablerIcon;
+export {};

package/src/lib/etl/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './pipeline-converter';
+export * from './validation';
+export * from './status-utils';
+export * from './icon-mapper';
+export * from './dynamic-ports';
+export * from './config-field-utils';

package/src/lib/etl/utils/pipeline-converter.d.ts

@@ -0,0 +1,14 @@
+import { Node, Edge } from '@xyflow/react';
+import { PipelineDefinition, EtlNodeData, PipelineMetadata, BlockDescriptor } from '../types';
+/**
+ * Convert ReactFlow nodes/edges to PipelineDefinition
+ */
+export declare function convertToPipelineDefinition(nodes: Node<EtlNodeData>[], edges: Edge[], metadata: PipelineMetadata): PipelineDefinition;
+/**
+ * Convert PipelineDefinition to ReactFlow nodes/edges
+ */
+export declare function convertFromPipelineDefinition(definition: PipelineDefinition, blockDescriptors: Map<string, BlockDescriptor>): {
+    nodes: Node<EtlNodeData>[];
+    edges: Edge[];
+    metadata: PipelineMetadata;
+};