@d34dman/flowdrop 0.0.1 → 0.0.2

package/dist/utils/icons.js

@@ -7,93 +7,94 @@
  */
 export const DEFAULT_ICONS = {
     // Node fallback icons
-    NODE: "mdi:cube",
-    CATEGORY: "mdi:folder",
+    NODE: 'mdi:cube',
+    CATEGORY: 'mdi:folder',
     // UI action icons
-    ADD: "mdi:plus",
-    REMOVE: "mdi:minus",
-    EDIT: "mdi:pencil",
-    SAVE: "mdi:content-save",
-    LOAD: "mdi:folder-open",
-    EXPORT: "mdi:download",
-    IMPORT: "mdi:upload",
-    SEARCH: "mdi:magnify",
-    CLOSE: "mdi:close",
-    SETTINGS: "mdi:cog",
-    HELP: "mdi:help-circle",
+    ADD: 'mdi:plus',
+    REMOVE: 'mdi:minus',
+    EDIT: 'mdi:pencil',
+    SAVE: 'mdi:content-save',
+    LOAD: 'mdi:folder-open',
+    EXPORT: 'mdi:download',
+    IMPORT: 'mdi:upload',
+    SEARCH: 'mdi:magnify',
+    CLOSE: 'mdi:close',
+    SETTINGS: 'mdi:cog',
+    HELP: 'mdi:help-circle',
     // Status icons
-    SUCCESS: "mdi:check-circle",
-    ERROR: "mdi:alert-circle",
-    WARNING: "mdi:alert",
-    INFO: "mdi:information",
-    LOADING: "mdi:loading",
+    SUCCESS: 'mdi:check-circle',
+    ERROR: 'mdi:alert-circle',
+    WARNING: 'mdi:alert',
+    INFO: 'mdi:information',
+    LOADING: 'mdi:loading',
     // Navigation icons
-    HOME: "mdi:home",
-    BACK: "mdi:arrow-left",
-    FORWARD: "mdi:arrow-right",
-    UP: "mdi:arrow-up",
-    DOWN: "mdi:arrow-down",
+    HOME: 'mdi:home',
+    BACK: 'mdi:arrow-left',
+    FORWARD: 'mdi:arrow-right',
+    UP: 'mdi:arrow-up',
+    DOWN: 'mdi:arrow-down',
     // Workflow icons
-    WORKFLOW: "mdi:graph",
-    NODE_ADD: "mdi:plus-circle",
-    NODE_DELETE: "mdi:minus-circle",
-    CONNECTION: "mdi:connection",
+    WORKFLOW: 'mdi:graph',
+    NODE_ADD: 'mdi:plus-circle',
+    NODE_DELETE: 'mdi:minus-circle',
+    CONNECTION: 'mdi:connection',
     // Data icons
-    DATA: "mdi:database",
-    FILE: "mdi:file",
-    TEXT: "mdi:text",
-    JSON: "mdi:code-json",
+    DATA: 'mdi:database',
+    FILE: 'mdi:file',
+    TEXT: 'mdi:text',
+    JSON: 'mdi:code-json',
     // Model and processing icons
-    MODEL: "mdi:chip",
-    BRAIN: "mdi:brain",
-    VECTOR: "mdi:vector-point",
-    ROBOT: "mdi:robot",
+    MODEL: 'mdi:chip',
+    BRAIN: 'mdi:brain',
+    VECTOR: 'mdi:vector-point',
+    ROBOT: 'mdi:robot',
     // Tool icons
-    TOOL: "mdi:wrench",
-    CALCULATOR: "mdi:calculator",
-    CLOCK: "mdi:clock",
+    TOOL: 'mdi:wrench',
+    CALCULATOR: 'mdi:calculator',
+    CLOCK: 'mdi:clock',
     // Communication icons
-    CHAT: "mdi:chat",
-    MESSAGE: "mdi:message",
-    EMAIL: "mdi:email",
-    WEBHOOK: "mdi:webhook",
+    CHAT: 'mdi:chat',
+    MESSAGE: 'mdi:message',
+    EMAIL: 'mdi:email',
+    WEBHOOK: 'mdi:webhook',
     // Storage icons
-    STORAGE: "mdi:database",
-    MEMORY: "mdi:memory",
-    CACHE: "mdi:cached",
+    STORAGE: 'mdi:database',
+    MEMORY: 'mdi:memory',
+    CACHE: 'mdi:cached',
     // Processing icons
-    PROCESS: "mdi:cog",
-    FILTER: "mdi:filter",
-    SORT: "mdi:sort",
-    TRANSFORM: "mdi:transform",
+    PROCESS: 'mdi:cog',
+    FILTER: 'mdi:filter',
+    SORT: 'mdi:sort',
+    TRANSFORM: 'mdi:transform',
     // Logic icons
-    LOGIC: "mdi:git-branch",
-    CONDITION: "mdi:source-fork",
-    LOOP: "mdi:loop",
+    LOGIC: 'mdi:git-branch',
+    CONDITION: 'mdi:source-fork',
+    LOOP: 'mdi:loop',
     // Integration icons
-    API: "mdi:api",
-    LINK: "mdi:link",
-    PLUGIN: "mdi:puzzle",
-    BUNDLE: "mdi:package-variant"
+    API: 'mdi:api',
+    LINK: 'mdi:link',
+    PLUGIN: 'mdi:puzzle',
+    BUNDLE: 'mdi:package-variant'
 };
 /**
  * Category-specific icons matching Langflow's visual style
  */
 export const CATEGORY_ICONS = {
-    "inputs": "mdi:arrow-down-circle",
-    "outputs": "mdi:arrow-up-circle",
-    "prompts": "mdi:message-text",
-    "models": "mdi:robot",
-    "processing": "mdi:cog",
-    "logic": "mdi:git-branch",
-    "data": "mdi:database",
-    "helpers": "mdi:help-circle",
-    "tools": "mdi:wrench",
-    "vector stores": "mdi:vector-square",
-    "embeddings": "mdi:vector-point",
-    "memories": "mdi:brain",
-    "agents": "mdi:account-cog",
-    "bundles": "mdi:package-variant"
+    inputs: 'mdi:arrow-down-circle',
+    outputs: 'mdi:arrow-up-circle',
+    prompts: 'mdi:message-text',
+    models: 'mdi:robot',
+    processing: 'mdi:cog',
+    logic: 'mdi:source-branch',
+    data: 'mdi:database',
+    helpers: 'mdi:help-circle',
+    tools: 'mdi:wrench',
+    'vector stores': 'mdi:vector-square',
+    embeddings: 'mdi:vector-polygon',
+    memories: 'mdi:brain',
+    agents: 'mdi:account-cog',
+    ai: 'mdi:artificial-intelligence',
+    bundles: 'mdi:package-variant'
 };
 /**
  * Get the appropriate icon for a node

package/dist/utils/nodeStatus.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Node Status Utility Functions
+ * Provides utilities for managing and displaying node execution status
+ */
+import type { NodeExecutionStatus, NodeExecutionInfo } from '../types/index.js';
+/**
+ * Get the display color for a node execution status
+ */
+export declare function getStatusColor(status: NodeExecutionStatus): string;
+/**
+ * Get the display icon for a node execution status
+ */
+export declare function getStatusIcon(status: NodeExecutionStatus): string;
+/**
+ * Get the display label for a node execution status
+ */
+export declare function getStatusLabel(status: NodeExecutionStatus): string;
+/**
+ * Get the background color for a node execution status overlay
+ */
+export declare function getStatusBackgroundColor(status: NodeExecutionStatus): string;
+/**
+ * Get the text color for a node execution status overlay
+ */
+export declare function getStatusTextColor(status: NodeExecutionStatus): string;
+/**
+ * Create a default NodeExecutionInfo object
+ */
+export declare function createDefaultExecutionInfo(): NodeExecutionInfo;
+/**
+ * Update node execution info when execution starts
+ */
+export declare function updateExecutionStart(executionInfo: NodeExecutionInfo): NodeExecutionInfo;
+/**
+ * Update node execution info when execution completes successfully
+ */
+export declare function updateExecutionComplete(executionInfo: NodeExecutionInfo, duration: number): NodeExecutionInfo;
+/**
+ * Update node execution info when execution fails
+ */
+export declare function updateExecutionFailed(executionInfo: NodeExecutionInfo, error: string, duration: number): NodeExecutionInfo;
+/**
+ * Reset node execution info
+ */
+export declare function resetExecutionInfo(executionInfo: NodeExecutionInfo): NodeExecutionInfo;
+/**
+ * Format execution duration for display
+ */
+export declare function formatExecutionDuration(duration?: number): string;
+/**
+ * Format last executed timestamp for display
+ */
+export declare function formatLastExecuted(timestamp?: string): string;

package/dist/utils/nodeStatus.js

@@ -0,0 +1,183 @@
+/**
+ * Node Status Utility Functions
+ * Provides utilities for managing and displaying node execution status
+ */
+/**
+ * Get the display color for a node execution status
+ */
+export function getStatusColor(status) {
+    const statusColors = {
+        idle: '#6b7280', // gray
+        pending: '#f59e0b', // amber
+        running: '#3b82f6', // blue
+        completed: '#10b981', // emerald
+        failed: '#ef4444', // red
+        cancelled: '#6b7280', // gray
+        skipped: '#8b5cf6' // violet
+    };
+    return statusColors[status] || statusColors.idle;
+}
+/**
+ * Get the display icon for a node execution status
+ */
+export function getStatusIcon(status) {
+    const statusIcons = {
+        idle: 'mdi:circle-outline',
+        pending: 'mdi:clock-outline',
+        running: 'mdi:loading',
+        completed: 'mdi:check-circle',
+        failed: 'mdi:alert-circle',
+        cancelled: 'mdi:cancel',
+        skipped: 'mdi:skip-next'
+    };
+    return statusIcons[status] || statusIcons.idle;
+}
+/**
+ * Get the display label for a node execution status
+ */
+export function getStatusLabel(status) {
+    const statusLabels = {
+        idle: 'Idle',
+        pending: 'Pending',
+        running: 'Running',
+        completed: 'Completed',
+        failed: 'Failed',
+        cancelled: 'Cancelled',
+        skipped: 'Skipped'
+    };
+    return statusLabels[status] || statusLabels.idle;
+}
+/**
+ * Get the background color for a node execution status overlay
+ */
+export function getStatusBackgroundColor(status) {
+    const statusBackgroundColors = {
+        idle: '#f9fafb', // light gray
+        pending: '#fef3c7', // light amber
+        running: '#dbeafe', // light blue
+        completed: '#d1fae5', // light emerald
+        failed: '#fee2e2', // light red
+        cancelled: '#f3f4f6', // light gray
+        skipped: '#ede9fe' // light violet
+    };
+    return statusBackgroundColors[status] || statusBackgroundColors.idle;
+}
+/**
+ * Get the text color for a node execution status overlay
+ */
+export function getStatusTextColor(status) {
+    const statusTextColors = {
+        idle: '#6b7280', // gray
+        pending: '#d97706', // amber
+        running: '#1d4ed8', // blue
+        completed: '#059669', // emerald
+        failed: '#dc2626', // red
+        cancelled: '#6b7280', // gray
+        skipped: '#7c3aed' // violet
+    };
+    return statusTextColors[status] || statusTextColors.idle;
+}
+/**
+ * Create a default NodeExecutionInfo object
+ */
+export function createDefaultExecutionInfo() {
+    return {
+        status: 'idle',
+        executionCount: 0,
+        isExecuting: false
+    };
+}
+/**
+ * Update node execution info when execution starts
+ */
+export function updateExecutionStart(executionInfo) {
+    return {
+        ...executionInfo,
+        status: 'running',
+        isExecuting: true
+    };
+}
+/**
+ * Update node execution info when execution completes successfully
+ */
+export function updateExecutionComplete(executionInfo, duration) {
+    return {
+        ...executionInfo,
+        status: 'completed',
+        executionCount: executionInfo.executionCount + 1,
+        lastExecuted: new Date().toISOString(),
+        lastExecutionDuration: duration,
+        isExecuting: false,
+        lastError: undefined // Clear any previous error
+    };
+}
+/**
+ * Update node execution info when execution fails
+ */
+export function updateExecutionFailed(executionInfo, error, duration) {
+    return {
+        ...executionInfo,
+        status: 'failed',
+        executionCount: executionInfo.executionCount + 1,
+        lastExecuted: new Date().toISOString(),
+        lastExecutionDuration: duration,
+        isExecuting: false,
+        lastError: error
+    };
+}
+/**
+ * Reset node execution info
+ */
+export function resetExecutionInfo(executionInfo) {
+    return {
+        ...executionInfo,
+        status: 'idle',
+        isExecuting: false,
+        lastError: undefined
+    };
+}
+/**
+ * Format execution duration for display
+ */
+export function formatExecutionDuration(duration) {
+    if (!duration)
+        return 'N/A';
+    if (duration < 1000) {
+        return `${Math.round(duration)}ms`;
+    }
+    else if (duration < 60000) {
+        return `${(duration / 1000).toFixed(1)}s`;
+    }
+    else {
+        const minutes = Math.floor(duration / 60000);
+        const seconds = Math.floor((duration % 60000) / 1000);
+        return `${minutes}m ${seconds}s`;
+    }
+}
+/**
+ * Format last executed timestamp for display
+ */
+export function formatLastExecuted(timestamp) {
+    if (!timestamp)
+        return 'Never';
+    const date = new Date(timestamp);
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    if (diffMs < 60000) {
+        // Less than 1 minute
+        return 'Just now';
+    }
+    else if (diffMs < 3600000) {
+        // Less than 1 hour
+        const minutes = Math.floor(diffMs / 60000);
+        return `${minutes}m ago`;
+    }
+    else if (diffMs < 86400000) {
+        // Less than 1 day
+        const hours = Math.floor(diffMs / 3600000);
+        return `${hours}h ago`;
+    }
+    else {
+        return date.toLocaleDateString();
+    }
+}

package/dist/utils/nodeTypes.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Node type utilities for FlowDrop
+ * Handles dynamic node type resolution based on NodeMetadata
+ */
+import type { NodeType, NodeMetadata } from '../types/index.js';
+/**
+ * Gets the SvelteFlow component name for a given NodeType
+ */
+export declare function getComponentNameForNodeType(nodeType: NodeType): string;
+/**
+ * Gets the available node types for a given NodeMetadata
+ * Priority: supportedTypes > type > "default"
+ */
+export declare function getAvailableNodeTypes(metadata: NodeMetadata): NodeType[];
+/**
+ * Gets the primary (default) node type for a given NodeMetadata
+ * This is used when no specific type is configured by the user
+ */
+export declare function getPrimaryNodeType(metadata: NodeMetadata): NodeType;
+/**
+ * Determines the appropriate node type based on configuration and metadata
+ * Priority:
+ * 1. configNodeType (if valid for this metadata)
+ * 2. metadata.type (if valid)
+ * 3. First supportedType
+ * 4. "default"
+ */
+export declare function resolveNodeType(metadata: NodeMetadata, configNodeType?: string): NodeType;
+/**
+ * Gets the SvelteFlow component name for resolved node type
+ * This replaces the old mapNodeType function
+ */
+export declare function resolveComponentName(metadata: NodeMetadata, configNodeType?: string): string;
+/**
+ * Validates if a node type is supported by the given metadata
+ */
+export declare function isNodeTypeSupported(metadata: NodeMetadata, nodeType: NodeType): boolean;
+/**
+ * Gets enum options for node type configuration
+ * Used in config schemas to show available options
+ */
+export declare function getNodeTypeEnumOptions(metadata: NodeMetadata): {
+    enum: string[];
+    enumNames: string[];
+};
+/**
+ * Creates a nodeType config property that respects supportedTypes
+ * This replaces hardcoded enum values in config schemas
+ */
+export declare function createNodeTypeConfigProperty(metadata: NodeMetadata, defaultType?: NodeType): {
+    type: "string";
+    title: string;
+    description: string;
+    default: NodeType;
+    enum: string[];
+    enumNames: string[];
+};

package/dist/utils/nodeTypes.js

@@ -0,0 +1,109 @@
+/**
+ * Node type utilities for FlowDrop
+ * Handles dynamic node type resolution based on NodeMetadata
+ */
+/**
+ * Maps NodeType to SvelteFlow component names
+ */
+const NODE_TYPE_TO_COMPONENT_MAP = {
+    note: 'note',
+    simple: 'simple',
+    square: 'square',
+    tool: 'tool',
+    gateway: 'gateway',
+    default: 'workflowNode'
+};
+/**
+ * Gets the SvelteFlow component name for a given NodeType
+ */
+export function getComponentNameForNodeType(nodeType) {
+    return NODE_TYPE_TO_COMPONENT_MAP[nodeType] || 'workflowNode';
+}
+/**
+ * Gets the available node types for a given NodeMetadata
+ * Priority: supportedTypes > type > "default"
+ */
+export function getAvailableNodeTypes(metadata) {
+    if (metadata.supportedTypes && metadata.supportedTypes.length > 0) {
+        return metadata.supportedTypes;
+    }
+    if (metadata.type) {
+        return [metadata.type];
+    }
+    return ['default'];
+}
+/**
+ * Gets the primary (default) node type for a given NodeMetadata
+ * This is used when no specific type is configured by the user
+ */
+export function getPrimaryNodeType(metadata) {
+    const availableTypes = getAvailableNodeTypes(metadata);
+    return availableTypes[0];
+}
+/**
+ * Determines the appropriate node type based on configuration and metadata
+ * Priority:
+ * 1. configNodeType (if valid for this metadata)
+ * 2. metadata.type (if valid)
+ * 3. First supportedType
+ * 4. "default"
+ */
+export function resolveNodeType(metadata, configNodeType) {
+    const availableTypes = getAvailableNodeTypes(metadata);
+    // Check if configNodeType is valid for this metadata
+    if (configNodeType && availableTypes.includes(configNodeType)) {
+        return configNodeType;
+    }
+    // Fall back to primary type
+    return getPrimaryNodeType(metadata);
+}
+/**
+ * Gets the SvelteFlow component name for resolved node type
+ * This replaces the old mapNodeType function
+ */
+export function resolveComponentName(metadata, configNodeType) {
+    const nodeType = resolveNodeType(metadata, configNodeType);
+    return getComponentNameForNodeType(nodeType);
+}
+/**
+ * Validates if a node type is supported by the given metadata
+ */
+export function isNodeTypeSupported(metadata, nodeType) {
+    const availableTypes = getAvailableNodeTypes(metadata);
+    return availableTypes.includes(nodeType);
+}
+/**
+ * Gets enum options for node type configuration
+ * Used in config schemas to show available options
+ */
+export function getNodeTypeEnumOptions(metadata) {
+    const availableTypes = getAvailableNodeTypes(metadata);
+    const typeDisplayNames = {
+        note: 'Note (sticky note style)',
+        simple: 'Simple (compact layout)',
+        square: 'Square (geometric layout)',
+        tool: 'Tool (specialized for agent tools)',
+        gateway: 'Gateway (branching control flow)',
+        default: 'Default (standard workflow node)'
+    };
+    return {
+        enum: availableTypes,
+        enumNames: availableTypes.map((type) => typeDisplayNames[type] || type)
+    };
+}
+/**
+ * Creates a nodeType config property that respects supportedTypes
+ * This replaces hardcoded enum values in config schemas
+ */
+export function createNodeTypeConfigProperty(metadata, defaultType) {
+    const { enum: enumValues, enumNames } = getNodeTypeEnumOptions(metadata);
+    const primaryType = defaultType || getPrimaryNodeType(metadata);
+    return {
+        type: 'string',
+        title: 'Node Type',
+        description: 'Choose the visual representation for this node',
+        default: primaryType,
+        enum: enumValues,
+        enumNames
+    };
+}

package/dist/utils/nodeWrapper.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Node Wrapper Utilities
+ * Provides utilities for wrapping nodes with status overlays
+ */
+import type { NodeExecutionInfo } from '../types/index.js';
+/**
+ * Configuration for node status overlay
+ */
+export interface NodeStatusConfig {
+    position?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    size?: 'sm' | 'md' | 'lg';
+    showDetails?: boolean;
+}
+/**
+ * Default configuration for node status overlays
+ */
+export declare const DEFAULT_NODE_STATUS_CONFIG: NodeStatusConfig;
+/**
+ * Create a node wrapper configuration
+ */
+export declare function createNodeWrapperConfig(nodeId: string, executionInfo?: NodeExecutionInfo, config?: NodeStatusConfig): {
+    nodeId: string;
+    executionInfo?: NodeExecutionInfo;
+    statusPosition: NodeStatusConfig['position'];
+    statusSize: NodeStatusConfig['size'];
+    showStatusDetails: boolean;
+};
+/**
+ * Check if a node should show status overlay
+ */
+export declare function shouldShowNodeStatus(executionInfo?: NodeExecutionInfo): boolean;
+/**
+ * Get optimal status position based on node type
+ */
+export declare function getOptimalStatusPosition(nodeType: string): NodeStatusConfig['position'];
+/**
+ * Get optimal status size based on node type
+ */
+export declare function getOptimalStatusSize(nodeType: string): NodeStatusConfig['size'];

package/dist/utils/nodeWrapper.js

@@ -0,0 +1,62 @@
+/**
+ * Node Wrapper Utilities
+ * Provides utilities for wrapping nodes with status overlays
+ */
+/**
+ * Default configuration for node status overlays
+ */
+export const DEFAULT_NODE_STATUS_CONFIG = {
+    position: 'top-right',
+    size: 'md',
+    showDetails: true
+};
+/**
+ * Create a node wrapper configuration
+ */
+export function createNodeWrapperConfig(nodeId, executionInfo, config = {}) {
+    return {
+        nodeId,
+        executionInfo,
+        statusPosition: config.position || DEFAULT_NODE_STATUS_CONFIG.position,
+        statusSize: config.size || DEFAULT_NODE_STATUS_CONFIG.size,
+        showStatusDetails: config.showDetails ?? DEFAULT_NODE_STATUS_CONFIG.showDetails
+    };
+}
+/**
+ * Check if a node should show status overlay
+ */
+export function shouldShowNodeStatus(executionInfo) {
+    if (!executionInfo)
+        return false;
+    return (executionInfo.status !== 'idle' || executionInfo.executionCount > 0 || executionInfo.isExecuting);
+}
+/**
+ * Get optimal status position based on node type
+ */
+export function getOptimalStatusPosition(nodeType) {
+    switch (nodeType) {
+        case 'tool':
+            return 'top-left';
+        case 'note':
+            return 'bottom-right';
+        case 'simple':
+        case 'square':
+        default:
+            return 'top-right';
+    }
+}
+/**
+ * Get optimal status size based on node type
+ */
+export function getOptimalStatusSize(nodeType) {
+    switch (nodeType) {
+        case 'tool':
+            return 'sm';
+        case 'note':
+            return 'sm';
+        case 'simple':
+        case 'square':
+        default:
+            return 'md';
+    }
+}