@d34dman/flowdrop 0.0.1 → 0.0.3

package/dist/types/index.d.ts

@@ -1,35 +1,92 @@
 /**
  * Core types for the Workflow Library
  */
-import type { Node, Edge, XYPosition } from "@xyflow/svelte";
-import { ConnectionLineType } from "@xyflow/svelte";
+import type { Node, Edge, XYPosition } from '@xyflow/svelte';
+import { ConnectionLineType } from '@xyflow/svelte';
+import type { EndpointConfig } from '../config/endpoints.js';
 /**
  * Node category types for organizing nodes in the sidebar
- * Based on Langflow's actual categories
+ * Based on actual API response categories
  */
-export type NodeCategory = "inputs" | "outputs" | "prompts" | "models" | "processing" | "logic" | "data" | "helpers" | "tools" | "vector stores" | "embeddings" | "memories" | "agents" | "bundles";
+export type NodeCategory = 'inputs' | 'outputs' | 'prompts' | 'models' | 'processing' | 'logic' | 'data' | 'tools' | 'helpers' | 'vector stores' | 'embeddings' | 'memories' | 'agents' | 'ai' | 'bundles';
 /**
- * Node input/output types
+ * Port data type configuration
  */
-export type NodeDataType = "string" | "text" | "number" | "integer" | "float" | "boolean" | "array" | "list" | "object" | "json" | "file" | "document" | "image" | "picture" | "audio" | "sound" | "video" | "movie" | "url" | "email" | "date" | "datetime" | "time";
+export interface PortDataTypeConfig {
+    /** Unique identifier for the data type */
+    id: string;
+    /** Display name for the data type */
+    name: string;
+    /** Description of the data type */
+    description?: string;
+    /** Color for the data type (CSS color value) */
+    color: string;
+    /** Category grouping for the data type */
+    category?: string;
+    /** Alternative names/aliases for this data type */
+    aliases?: string[];
+    /** Whether this data type is enabled */
+    enabled?: boolean;
+}
+/**
+ * Port compatibility rule configuration
+ * Simple rule: sourceType can connect TO targetType
+ */
+export interface PortCompatibilityRule {
+    /** Source data type ID (what you're connecting FROM) */
+    from: string;
+    /** Target data type ID (what you're connecting TO) */
+    to: string;
+    /** Optional description of why this connection is allowed */
+    description?: string;
+}
+/**
+ * Complete port configuration system
+ */
+export interface PortConfig {
+    /** Available data types */
+    dataTypes: PortDataTypeConfig[];
+    /** Compatibility rules between data types */
+    compatibilityRules: PortCompatibilityRule[];
+    /** Default data type to use when none specified */
+    defaultDataType: string;
+    /** Version of the port configuration */
+    version?: string;
+}
+/**
+ * Node data type - now dynamic based on configuration
+ * Will be string literals of available data type IDs
+ */
+export type NodeDataType = string;
 /**
  * Node port configuration
  */
 export interface NodePort {
     id: string;
     name: string;
-    type: "input" | "output";
+    type: 'input' | 'output' | 'metadata';
     dataType: NodeDataType;
     required?: boolean;
     description?: string;
     defaultValue?: unknown;
 }
+/**
+ * Node types for explicit component rendering
+ */
+export type NodeType = 'note' | 'simple' | 'square' | 'tool' | 'gateway' | 'default';
 /**
  * Node configuration metadata
  */
 export interface NodeMetadata {
     id: string;
     name: string;
+    type?: NodeType;
+    /**
+     * Array of supported node types that this node can be rendered as.
+     * If not specified, defaults to the single 'type' field or 'default'.
+     * This allows nodes to support multiple rendering modes (e.g., both 'simple' and 'default').
+     */
+    supportedTypes?: NodeType[];
     description: string;
     category: NodeCategory;
     version: string;
@@ -37,15 +94,145 @@ export interface NodeMetadata {
     color?: string;
     inputs: NodePort[];
     outputs: NodePort[];
-    configSchema?: Record<string, unknown>;
+    configSchema?: ConfigSchema;
     tags?: string[];
 }
 /**
- * Node configuration data
+ * Common base interface for all schema properties
+ */
+export interface BaseProperty {
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object' | 'integer' | 'mixed' | 'float';
+    description?: string;
+    title?: string;
+    default?: unknown;
+    enum?: unknown[];
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    items?: BaseProperty;
+    properties?: Record<string, BaseProperty>;
+    [key: string]: unknown;
+}
+/**
+ * Common base interface for all schemas
+ */
+export interface BaseSchema {
+    type: 'object';
+    properties: Record<string, BaseProperty>;
+    required?: string[];
+    additionalProperties?: boolean;
+}
+/**
+ * Configuration schema property with specific attributes
+ */
+export interface ConfigProperty extends BaseProperty {
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object' | 'integer';
+    title?: string;
+    description?: string;
+    default?: unknown;
+    enum?: unknown[];
+    multiple?: boolean;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: 'multiline' | 'hidden' | string;
+    items?: ConfigProperty;
+    properties?: Record<string, ConfigProperty>;
+    [key: string]: unknown;
+}
+/**
+ * Configuration schema interface
+ */
+export interface ConfigSchema extends BaseSchema {
+    properties: Record<string, ConfigProperty>;
+}
+/**
+ * Input schema property with specific attributes
+ */
+export interface InputProperty extends BaseProperty {
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object' | 'integer' | 'mixed';
+    title?: string;
+    description?: string;
+    required?: boolean;
+    default?: unknown;
+    enum?: unknown[];
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: 'multiline' | string;
+    items?: InputProperty;
+    properties?: Record<string, InputProperty>;
+    [key: string]: unknown;
+}
+/**
+ * Input schema interface
  */
-export interface NodeConfig {
+export interface InputSchema extends BaseSchema {
+    properties: Record<string, InputProperty>;
+}
+/**
+ * Output schema property with specific attributes
+ */
+export interface OutputProperty extends BaseProperty {
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object' | 'integer' | 'mixed' | 'float';
+    description: string;
+    title?: string;
+    default?: unknown;
+    enum?: unknown[];
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    items?: OutputProperty;
+    properties?: Record<string, OutputProperty>;
     [key: string]: unknown;
 }
+/**
+ * Output schema interface
+ */
+export interface OutputSchema extends BaseSchema {
+    properties: Record<string, OutputProperty>;
+}
+/**
+ * Union type for all schema types
+ */
+export type Schema = ConfigSchema | InputSchema | OutputSchema;
+/**
+ * Union type for all property types
+ */
+export type Property = ConfigProperty | InputProperty | OutputProperty;
+/**
+ * Schema type discriminator
+ */
+export type SchemaType = 'config' | 'input' | 'output';
+/**
+ * Utility type to get the appropriate property type based on schema type
+ */
+export type SchemaProperty<T extends SchemaType> = T extends 'config' ? ConfigProperty : T extends 'input' ? InputProperty : T extends 'output' ? OutputProperty : never;
+/**
+ * Utility type to get the appropriate schema type based on schema type
+ */
+export type SchemaTypeMap<T extends SchemaType> = T extends 'config' ? ConfigSchema : T extends 'input' ? InputSchema : T extends 'output' ? OutputSchema : never;
+/**
+ * Node configuration values
+ * Key-value pairs of user-entered configuration values
+ */
+export interface ConfigValues {
+    [key: string]: unknown;
+}
+/**
+ * Node configuration type (alias for backward compatibility)
+ */
+export type NodeConfig = ConfigValues;
 /**
  * Extended node type for workflows
  */
@@ -56,11 +243,13 @@ export interface WorkflowNode extends Node {
     deletable?: boolean;
     data: {
         label: string;
-        config: NodeConfig;
+        config: ConfigValues;
         metadata: NodeMetadata;
         isProcessing?: boolean;
         error?: string;
         nodeId?: string;
+        /** Node execution tracking information */
+        executionInfo?: NodeExecutionInfo;
     };
 }
 /**
@@ -78,6 +267,9 @@ export interface WorkflowEdge extends Edge {
     data?: {
         label?: string;
         condition?: string;
+        isToolConnection?: boolean;
+        targetNodeType?: string;
+        targetCategory?: string;
     };
 }
 /**
@@ -95,6 +287,8 @@ export interface Workflow {
         updatedAt: string;
         author?: string;
         tags?: string[];
+        versionId?: string;
+        updateNumber?: number;
     };
 }
 /**
@@ -106,16 +300,34 @@ export interface ApiResponse<T> {
     error?: string;
     message?: string;
 }
-export interface NodesResponse extends ApiResponse<NodeMetadata[]> {
-}
-export interface WorkflowResponse extends ApiResponse<Workflow> {
-}
-export interface WorkflowsResponse extends ApiResponse<Workflow[]> {
+export type NodesResponse = ApiResponse<NodeMetadata[]>;
+export type WorkflowResponse = ApiResponse<Workflow>;
+export type WorkflowsResponse = ApiResponse<Workflow[]>;
+/**
+ * Node execution status enum
+ */
+export type NodeExecutionStatus = 'idle' | 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'skipped';
+/**
+ * Node execution tracking information
+ */
+export interface NodeExecutionInfo {
+    /** Current execution status */
+    status: NodeExecutionStatus;
+    /** Total number of times this node has been executed */
+    executionCount: number;
+    /** Last execution timestamp */
+    lastExecuted?: string;
+    /** Last execution duration in milliseconds */
+    lastExecutionDuration?: number;
+    /** Last error message if execution failed */
+    lastError?: string;
+    /** Whether the node is currently being executed */
+    isExecuting: boolean;
 }
 /**
  * Workflow execution status
  */
-export type ExecutionStatus = "idle" | "running" | "completed" | "failed" | "cancelled";
+export type ExecutionStatus = 'idle' | 'running' | 'completed' | 'failed' | 'cancelled';
 /**
  * Workflow execution result
  */
@@ -133,8 +345,8 @@ export interface ExecutionResult {
  * Library configuration
  */
 export interface FlowDropConfig {
-    apiBaseUrl: string;
-    theme?: "light" | "dark" | "auto";
+    endpointConfig?: EndpointConfig;
+    theme?: 'light' | 'dark' | 'auto';
     enableDebug?: boolean;
     autoSave?: boolean;
     autoSaveInterval?: number;

package/dist/types/index.js

@@ -1,4 +1,4 @@
 /**
  * Core types for the Workflow Library
  */
-import { ConnectionLineType } from "@xyflow/svelte";
+import { ConnectionLineType } from '@xyflow/svelte';

package/dist/utils/colors.d.ts

@@ -3,22 +3,14 @@
  * Ensures consistent category colors across sidebar and canvas
  * Uses BEM syntax for CSS classes
  */
-import type { NodeCategory } from "../types/index.js";
-/**
- * Color configuration type for consistent color objects
- */
-export interface ColorConfig {
-    background: string;
-    accent: string;
-    text: string;
-    border: string;
-}
+import type { NodeCategory, PortDataTypeConfig } from '../types/index.js';
 /**
  * Category color mapping to reference tokens (CSS variables)
  */
 export declare const CATEGORY_COLOR_TOKENS: Record<NodeCategory, string>;
 /**
  * Data type color mapping to reference tokens (CSS variables)
+ * @deprecated Use getDataTypeColorToken() with port configuration instead
  */
 export declare const DATA_TYPE_COLOR_TOKENS: Record<string, string>;
 /**
@@ -26,19 +18,32 @@ export declare const DATA_TYPE_COLOR_TOKENS: Record<string, string>;
  */
 export declare function getCategoryColorToken(category: NodeCategory): string;
 /**
- * Get the reference color token for a data type
+ * Get the reference color token for a data type (configurable version)
  */
 export declare function getDataTypeColorToken(dataType: string): string;
+/**
+ * Get data type configuration from port config
+ */
+export declare function getDataTypeConfig(dataType: string): PortDataTypeConfig | undefined;
+/**
+ * Get all available data types from port configuration
+ */
+export declare function getAvailableDataTypes(): PortDataTypeConfig[];
 /**
  * Default colors for fallback cases
  */
-export declare const DEFAULT_COLORS: ColorConfig;
+export declare const DEFAULT_COLORS: {
+    background: string;
+    accent: string;
+    text: string;
+    border: string;
+};
 /**
  * Get category colors
  * @param category - The node category
  * @returns The color configuration for the category
  */
-export declare function getCategoryColors(category: NodeCategory): ColorConfig;
+export declare function getCategoryColors(category: NodeCategory): string;
 /**
  * Get category background color
  * @param category - The node category
@@ -46,7 +51,7 @@ export declare function getCategoryColors(category: NodeCategory): ColorConfig;
  */
 export declare function getCategoryBackground(category: NodeCategory): string;
 /**
- * Get category accent color (for icons, highlights)
+ * Get category accent color
  * @param category - The node category
  * @returns The accent color class
  */
@@ -64,58 +69,87 @@ export declare function getCategoryText(category: NodeCategory): string;
  */
 export declare function getCategoryBorder(category: NodeCategory): string;
 /**
- * Get node colors based on category and status
+ * Get node colors based on category and state
  * @param category - The node category
- * @param isError - Whether the node has an error
+ * @param isError - Whether the node is in error state
  * @param isProcessing - Whether the node is processing
  * @param isSelected - Whether the node is selected
- * @returns The color configuration for the node
+ * @returns The color configuration object
  */
-export declare function getNodeColors(category: NodeCategory, isError?: boolean, isProcessing?: boolean, isSelected?: boolean): ColorConfig;
+export declare function getNodeColors(category: NodeCategory, isError?: boolean, isProcessing?: boolean, isSelected?: boolean): {
+    background: string;
+    accent: string;
+    text: string;
+    border: string;
+};
 /**
  * Get node background color
  * @param category - The node category
- * @param isError - Whether the node has an error
+ * @param isError - Whether the node is in error state
  * @param isProcessing - Whether the node is processing
  * @param isSelected - Whether the node is selected
- * @returns The background color class
+ * @returns The background color
  */
 export declare function getNodeBackground(category: NodeCategory, isError?: boolean, isProcessing?: boolean, isSelected?: boolean): string;
 /**
  * Get node accent color
  * @param category - The node category
- * @param isError - Whether the node has an error
+ * @param isError - Whether the node is in error state
  * @param isProcessing - Whether the node is processing
  * @param isSelected - Whether the node is selected
- * @returns The accent color class
+ * @returns The accent color
  */
 export declare function getNodeAccent(category: NodeCategory, isError?: boolean, isProcessing?: boolean, isSelected?: boolean): string;
 /**
  * Get node text color
  * @param category - The node category
- * @param isError - Whether the node has an error
+ * @param isError - Whether the node is in error state
  * @param isProcessing - Whether the node is processing
  * @param isSelected - Whether the node is selected
- * @returns The text color class
+ * @returns The text color
  */
 export declare function getNodeText(category: NodeCategory, isError?: boolean, isProcessing?: boolean, isSelected?: boolean): string;
 /**
  * Get node border color
  * @param category - The node category
- * @param isError - Whether the node has an error
+ * @param isError - Whether the node is in error state
  * @param isProcessing - Whether the node is processing
  * @param isSelected - Whether the node is selected
- * @returns The border color class
+ * @returns The border color
  */
 export declare function getNodeBorder(category: NodeCategory, isError?: boolean, isProcessing?: boolean, isSelected?: boolean): string;
 /**
- * Data type color mapping for ports (used in WorkflowNode, etc.)
- * These use BEM color classes for consistency
+ * Get data type color
+ * @param dataType - The data type
+ * @returns The color for the data type
  */
-export declare const dataTypeColors: Record<string, string>;
+export declare function getDataTypeColor(dataType: string): string;
 /**
- * Get data type color class
- * @param dataType - The data type string
- * @returns The color class for the data type
+ * Parse typed array notation and get display information
+ * @param dataType - The data type (e.g., "string[]", "number", "object[]")
+ * @returns Object with display information
  */
-export declare function getDataTypeColor(dataType: string): string;
+export declare function parseDataTypeDisplay(dataType: string): {
+    baseType: string;
+    isArray: boolean;
+    displayName: string;
+    elementType?: string;
+};
+/**
+ * Get formatted display text for a data type
+ * @param dataType - The data type
+ * @returns Formatted display text
+ */
+export declare function getDataTypeDisplayText(dataType: string): string;
+/**
+ * Check if a data type represents an array
+ * @param dataType - The data type
+ * @returns True if it's an array type
+ */
+export declare function isArrayDataType(dataType: string): boolean;
+/**
+ * Get the element type from an array data type
+ * @param arrayDataType - The array data type (e.g., "string[]")
+ * @returns The element type (e.g., "string") or null if not an array
+ */
+export declare function getArrayElementType(arrayDataType: string): string | null;