@d34dman/flowdrop 0.0.16 → 0.0.18

package/dist/types/auth.js

@@ -48,22 +48,22 @@ export class StaticAuthProvider {
     constructor(config) {
         this.headers = {};
         switch (config.type) {
-            case "bearer":
+            case 'bearer':
                 if (config.token) {
-                    this.headers["Authorization"] = `Bearer ${config.token}`;
+                    this.headers['Authorization'] = `Bearer ${config.token}`;
                 }
                 break;
-            case "api_key":
+            case 'api_key':
                 if (config.apiKey) {
-                    this.headers["X-API-Key"] = config.apiKey;
+                    this.headers['X-API-Key'] = config.apiKey;
                 }
                 break;
-            case "custom":
+            case 'custom':
                 if (config.headers) {
                     this.headers = { ...config.headers };
                 }
                 break;
-            case "none":
+            case 'none':
             default:
                 // No headers needed
                 break;
@@ -237,7 +237,7 @@ export class NoAuthProvider {
  * @returns AuthProvider instance
  */
 export function createAuthProviderFromLegacyConfig(authConfig) {
-    if (!authConfig || authConfig.type === "none") {
+    if (!authConfig || authConfig.type === 'none') {
         return new NoAuthProvider();
     }
     return new StaticAuthProvider(authConfig);

package/dist/types/events.d.ts

@@ -6,13 +6,13 @@
  *
  * @module types/events
  */
-import type { Workflow } from "./index.js";
+import type { Workflow } from './index.js';
 /**
  * Types of workflow changes
  *
  * Used to identify what kind of change triggered the onWorkflowChange event.
  */
-export type WorkflowChangeType = "node_add" | "node_remove" | "node_move" | "node_config" | "edge_add" | "edge_remove" | "metadata" | "name" | "description";
+export type WorkflowChangeType = 'node_add' | 'node_remove' | 'node_move' | 'node_config' | 'edge_add' | 'edge_remove' | 'metadata' | 'name' | 'description';
 /**
  * High-level event handlers for enterprise integration
  *

package/dist/types/index.d.ts

@@ -71,9 +71,27 @@ export interface NodePort {
     defaultValue?: unknown;
 }
 /**
- * Node types for explicit component rendering
- */
-export type NodeType = 'note' | 'simple' | 'square' | 'tool' | 'gateway' | 'default';
+ * Built-in node types for explicit component rendering.
+ * These are the node types that ship with FlowDrop.
+ */
+export type BuiltinNodeType = 'note' | 'simple' | 'square' | 'tool' | 'gateway' | 'terminal' | 'default';
+/**
+ * Node type for component rendering.
+ * Includes built-in types and allows custom registered types.
+ *
+ * Built-in types: note, simple, square, tool, gateway, terminal, default
+ * Custom types: Any string registered via nodeComponentRegistry
+ *
+ * @example
+ * ```typescript
+ * // Built-in type
+ * const type: NodeType = "simple";
+ *
+ * // Custom registered type
+ * const customType: NodeType = "mylib:fancy";
+ * ```
+ */
+export type NodeType = BuiltinNodeType | (string & Record<never, never>);
 /**
  * Node configuration metadata
  */
@@ -85,6 +103,7 @@ export interface NodeMetadata {
      * 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').
+     * Can include both built-in types and custom registered types.
      */
     supportedTypes?: NodeType[];
     description: string;
@@ -252,6 +271,14 @@ export interface WorkflowNode extends Node {
         executionInfo?: NodeExecutionInfo;
     };
 }
+/**
+ * Edge category types based on source port data type
+ * Used for visual styling of edges on the canvas
+ * - trigger: For control flow connections (dataType: "trigger")
+ * - tool: Dashed amber line for tool connections (dataType: "tool")
+ * - data: Normal gray line for all other data connections
+ */
+export type EdgeCategory = 'trigger' | 'tool' | 'data';
 /**
  * Extended edge type for workflows
  */
@@ -267,6 +294,14 @@ export interface WorkflowEdge extends Edge {
     data?: {
         label?: string;
         condition?: string;
+        /** Edge metadata for API and persistence */
+        metadata?: {
+            /** Edge type for styling ("tool" or "data") */
+            edgeType?: EdgeCategory;
+            /** Data type of the source output port (e.g., "tool", "string", "number") */
+            sourcePortDataType?: string;
+        };
+        /** @deprecated Use metadata.edgeType instead - kept for backward compatibility */
         isToolConnection?: boolean;
         targetNodeType?: string;
         targetCategory?: string;

package/dist/utils/nodeTypes.d.ts

@@ -1,57 +1,112 @@
 /**
  * Node type utilities for FlowDrop
- * Handles dynamic node type resolution based on NodeMetadata
+ * Handles dynamic node type resolution based on NodeMetadata.
+ *
+ * This module provides utilities for:
+ * - Resolving which node type to use based on metadata and config
+ * - Getting available node types for a given metadata
+ * - Creating config schema properties for node type selection
+ *
+ * Works with both built-in types and custom registered types.
  */
 import type { NodeType, NodeMetadata } from '../types/index.js';
 /**
- * Gets the SvelteFlow component name for a given NodeType
+ * Gets the SvelteFlow component name for a given NodeType.
+ * Supports both built-in types and registered custom types.
+ *
+ * @param nodeType - The node type identifier
+ * @returns The component name to use
  */
-export declare function getComponentNameForNodeType(nodeType: NodeType): string;
+export declare function getComponentNameForNodeType(nodeType: NodeType | string): string;
 /**
- * Gets the available node types for a given NodeMetadata
+ * Gets the available node types for a given NodeMetadata.
  * Priority: supportedTypes > type > "default"
+ *
+ * @param metadata - The node metadata
+ * @returns Array of available node type identifiers
  */
-export declare function getAvailableNodeTypes(metadata: NodeMetadata): NodeType[];
+export declare function getAvailableNodeTypes(metadata: NodeMetadata): (NodeType | string)[];
 /**
- * Gets the primary (default) node type for a given NodeMetadata
- * This is used when no specific type is configured by the user
+ * Gets the primary (default) node type for a given NodeMetadata.
+ * This is used when no specific type is configured by the user.
+ *
+ * @param metadata - The node metadata
+ * @returns The primary node type
  */
-export declare function getPrimaryNodeType(metadata: NodeMetadata): NodeType;
+export declare function getPrimaryNodeType(metadata: NodeMetadata): NodeType | string;
 /**
- * Determines the appropriate node type based on configuration and metadata
+ * 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"
+ *
+ * @param metadata - The node metadata
+ * @param configNodeType - Optional type from user config
+ * @returns The resolved node type
  */
-export declare function resolveNodeType(metadata: NodeMetadata, configNodeType?: string): NodeType;
+export declare function resolveNodeType(metadata: NodeMetadata, configNodeType?: string): NodeType | string;
 /**
- * Gets the SvelteFlow component name for resolved node type
- * This replaces the old mapNodeType function
+ * Gets the SvelteFlow component name for resolved node type.
+ * This is the main function used by UniversalNode to determine which component to render.
+ *
+ * @param metadata - The node metadata
+ * @param configNodeType - Optional type from user config
+ * @returns The component name to use
  */
 export declare function resolveComponentName(metadata: NodeMetadata, configNodeType?: string): string;
 /**
- * Validates if a node type is supported by the given metadata
+ * Validates if a node type is supported by the given metadata.
+ *
+ * @param metadata - The node metadata
+ * @param nodeType - The type to check
+ * @returns true if the type is supported
  */
-export declare function isNodeTypeSupported(metadata: NodeMetadata, nodeType: NodeType): boolean;
+export declare function isNodeTypeSupported(metadata: NodeMetadata, nodeType: NodeType | string): boolean;
 /**
- * Gets enum options for node type configuration
- * Used in config schemas to show available options
+ * Gets enum options for node type configuration.
+ * Used in config schemas to show available options.
+ *
+ * This function combines:
+ * - Types specified in metadata.supportedTypes
+ * - Registered custom types (optionally filtered)
+ *
+ * @param metadata - The node metadata
+ * @param includeCustomTypes - Whether to include registered custom types
+ * @returns Object with enum values and display names
  */
-export declare function getNodeTypeEnumOptions(metadata: NodeMetadata): {
+export declare function getNodeTypeEnumOptions(metadata: NodeMetadata, includeCustomTypes?: boolean): {
     enum: string[];
     enumNames: string[];
 };
 /**
- * Creates a nodeType config property that respects supportedTypes
- * This replaces hardcoded enum values in config schemas
+ * Creates a nodeType config property that respects supportedTypes.
+ * This replaces hardcoded enum values in config schemas.
+ *
+ * @param metadata - The node metadata
+ * @param defaultType - Optional default type override
+ * @returns Config schema property object
  */
-export declare function createNodeTypeConfigProperty(metadata: NodeMetadata, defaultType?: NodeType): {
+export declare function createNodeTypeConfigProperty(metadata: NodeMetadata, defaultType?: NodeType | string): {
     type: "string";
     title: string;
     description: string;
-    default: NodeType;
+    default: string;
     enum: string[];
     enumNames: string[];
 };
+/**
+ * Check if a type string represents a valid registered or built-in type.
+ *
+ * @param type - The type to check
+ * @returns true if the type is valid
+ */
+export declare function isValidNodeType(type: string): boolean;
+/**
+ * Get all available node types (built-in + registered).
+ *
+ * @returns Array of all valid node type identifiers
+ */
+export declare function getAllNodeTypes(): string[];

package/dist/utils/nodeTypes.js

@@ -1,9 +1,19 @@
 /**
  * Node type utilities for FlowDrop
- * Handles dynamic node type resolution based on NodeMetadata
+ * Handles dynamic node type resolution based on NodeMetadata.
+ *
+ * This module provides utilities for:
+ * - Resolving which node type to use based on metadata and config
+ * - Getting available node types for a given metadata
+ * - Creating config schema properties for node type selection
+ *
+ * Works with both built-in types and custom registered types.
  */
+import { nodeComponentRegistry } from '../registry/nodeComponentRegistry.js';
+import { resolveBuiltinAlias, isBuiltinType } from '../registry/builtinNodes.js';
 /**
- * Maps NodeType to SvelteFlow component names
+ * Maps built-in NodeType to SvelteFlow component names.
+ * This is kept for backwards compatibility.
  */
 const NODE_TYPE_TO_COMPONENT_MAP = {
     note: 'note',
@@ -11,17 +21,48 @@ const NODE_TYPE_TO_COMPONENT_MAP = {
     square: 'square',
     tool: 'tool',
     gateway: 'gateway',
+    terminal: 'terminal',
     default: 'workflowNode'
 };
 /**
- * Gets the SvelteFlow component name for a given NodeType
+ * Display names for built-in node types.
+ */
+const TYPE_DISPLAY_NAMES = {
+    note: 'Note (sticky note style)',
+    simple: 'Simple (compact layout)',
+    square: 'Square (geometric layout)',
+    tool: 'Tool (specialized for agent tools)',
+    gateway: 'Gateway (branching control flow)',
+    terminal: 'Terminal (start/end/exit)',
+    default: 'Default (standard workflow node)'
+};
+/**
+ * Gets the SvelteFlow component name for a given NodeType.
+ * Supports both built-in types and registered custom types.
+ *
+ * @param nodeType - The node type identifier
+ * @returns The component name to use
  */
 export function getComponentNameForNodeType(nodeType) {
-    return NODE_TYPE_TO_COMPONENT_MAP[nodeType] || 'workflowNode';
+    // Resolve aliases first (e.g., "default" -> "workflowNode")
+    const resolvedType = resolveBuiltinAlias(nodeType);
+    // Check if it's registered in the registry
+    if (nodeComponentRegistry.has(resolvedType)) {
+        return resolvedType;
+    }
+    // Fall back to built-in mapping
+    if (nodeType in NODE_TYPE_TO_COMPONENT_MAP) {
+        return NODE_TYPE_TO_COMPONENT_MAP[nodeType];
+    }
+    // Unknown type - return as-is (might be a custom type)
+    return resolvedType;
 }
 /**
- * Gets the available node types for a given NodeMetadata
+ * Gets the available node types for a given NodeMetadata.
  * Priority: supportedTypes > type > "default"
+ *
+ * @param metadata - The node metadata
+ * @returns Array of available node type identifiers
  */
 export function getAvailableNodeTypes(metadata) {
     if (metadata.supportedTypes && metadata.supportedTypes.length > 0) {
@@ -33,71 +74,139 @@ export function getAvailableNodeTypes(metadata) {
     return ['default'];
 }
 /**
- * Gets the primary (default) node type for a given NodeMetadata
- * This is used when no specific type is configured by the user
+ * Gets the primary (default) node type for a given NodeMetadata.
+ * This is used when no specific type is configured by the user.
+ *
+ * @param metadata - The node metadata
+ * @returns The primary node type
  */
 export function getPrimaryNodeType(metadata) {
     const availableTypes = getAvailableNodeTypes(metadata);
     return availableTypes[0];
 }
 /**
- * Determines the appropriate node type based on configuration and metadata
+ * 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"
+ *
+ * @param metadata - The node metadata
+ * @param configNodeType - Optional type from user config
+ * @returns The resolved node type
  */
 export function resolveNodeType(metadata, configNodeType) {
     const availableTypes = getAvailableNodeTypes(metadata);
     // Check if configNodeType is valid for this metadata
-    if (configNodeType && availableTypes.includes(configNodeType)) {
-        return configNodeType;
+    if (configNodeType) {
+        // Resolve alias for comparison
+        const resolvedConfig = resolveBuiltinAlias(configNodeType);
+        // Check if it's in available types
+        if (availableTypes.includes(configNodeType) ||
+            availableTypes.includes(resolvedConfig)) {
+            return configNodeType;
+        }
+        // Check if it's a registered custom type
+        if (nodeComponentRegistry.has(configNodeType) || nodeComponentRegistry.has(resolvedConfig)) {
+            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
+ * Gets the SvelteFlow component name for resolved node type.
+ * This is the main function used by UniversalNode to determine which component to render.
+ *
+ * @param metadata - The node metadata
+ * @param configNodeType - Optional type from user config
+ * @returns The component name to use
  */
 export function resolveComponentName(metadata, configNodeType) {
     const nodeType = resolveNodeType(metadata, configNodeType);
     return getComponentNameForNodeType(nodeType);
 }
 /**
- * Validates if a node type is supported by the given metadata
+ * Validates if a node type is supported by the given metadata.
+ *
+ * @param metadata - The node metadata
+ * @param nodeType - The type to check
+ * @returns true if the type is supported
  */
 export function isNodeTypeSupported(metadata, nodeType) {
     const availableTypes = getAvailableNodeTypes(metadata);
-    return availableTypes.includes(nodeType);
+    // Check direct match
+    if (availableTypes.includes(nodeType)) {
+        return true;
+    }
+    // Check alias match
+    const resolvedType = resolveBuiltinAlias(nodeType);
+    if (availableTypes.includes(resolvedType)) {
+        return true;
+    }
+    // Check if it's a registered custom type that's in the available list
+    if (nodeComponentRegistry.has(nodeType)) {
+        return availableTypes.some((t) => t === nodeType || resolveBuiltinAlias(t) === nodeType);
+    }
+    return false;
 }
 /**
- * Gets enum options for node type configuration
- * Used in config schemas to show available options
+ * Gets enum options for node type configuration.
+ * Used in config schemas to show available options.
+ *
+ * This function combines:
+ * - Types specified in metadata.supportedTypes
+ * - Registered custom types (optionally filtered)
+ *
+ * @param metadata - The node metadata
+ * @param includeCustomTypes - Whether to include registered custom types
+ * @returns Object with enum values and display names
  */
-export function getNodeTypeEnumOptions(metadata) {
+export function getNodeTypeEnumOptions(metadata, includeCustomTypes = false) {
     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)
-    };
+    // Build enum values and names
+    const enumValues = [];
+    const enumNames = [];
+    for (const type of availableTypes) {
+        enumValues.push(type);
+        // Get display name from registry or fallback to built-in names
+        const registration = nodeComponentRegistry.get(type);
+        if (registration) {
+            enumNames.push(registration.displayName);
+        }
+        else if (type in TYPE_DISPLAY_NAMES) {
+            enumNames.push(TYPE_DISPLAY_NAMES[type]);
+        }
+        else {
+            // Format unknown type nicely
+            enumNames.push(formatTypeName(type));
+        }
+    }
+    // Optionally include all registered custom types
+    if (includeCustomTypes) {
+        const registrations = nodeComponentRegistry.filter({
+            predicate: (reg) => !isBuiltinType(reg.type) && !enumValues.includes(reg.type)
+        });
+        for (const reg of registrations) {
+            enumValues.push(reg.type);
+            enumNames.push(reg.displayName);
+        }
+    }
+    return { enum: enumValues, enumNames };
 }
 /**
- * Creates a nodeType config property that respects supportedTypes
- * This replaces hardcoded enum values in config schemas
+ * Creates a nodeType config property that respects supportedTypes.
+ * This replaces hardcoded enum values in config schemas.
+ *
+ * @param metadata - The node metadata
+ * @param defaultType - Optional default type override
+ * @returns Config schema property object
  */
 export function createNodeTypeConfigProperty(metadata, defaultType) {
     const { enum: enumValues, enumNames } = getNodeTypeEnumOptions(metadata);
-    const primaryType = defaultType || getPrimaryNodeType(metadata);
+    const primaryType = defaultType ?? getPrimaryNodeType(metadata);
     return {
         type: 'string',
         title: 'Node Type',
@@ -107,3 +216,44 @@ export function createNodeTypeConfigProperty(metadata, defaultType) {
         enumNames
     };
 }
+/**
+ * Check if a type string represents a valid registered or built-in type.
+ *
+ * @param type - The type to check
+ * @returns true if the type is valid
+ */
+export function isValidNodeType(type) {
+    return isBuiltinType(type) || nodeComponentRegistry.has(type);
+}
+/**
+ * Get all available node types (built-in + registered).
+ *
+ * @returns Array of all valid node type identifiers
+ */
+export function getAllNodeTypes() {
+    return nodeComponentRegistry.getTypes();
+}
+/**
+ * Format a type name for display when no display name is registered.
+ *
+ * @param type - The raw type string
+ * @returns Formatted display name
+ */
+function formatTypeName(type) {
+    // Handle namespaced types (e.g., "mylib:fancy" -> "Mylib: Fancy")
+    if (type.includes(':')) {
+        const [namespace, name] = type.split(':');
+        return `${capitalize(namespace)}: ${capitalize(name)}`;
+    }
+    // Capitalize and add spaces for camelCase
+    return capitalize(type.replace(/([A-Z])/g, ' $1').trim());
+}
+/**
+ * Capitalize the first letter of a string.
+ *
+ * @param str - The string to capitalize
+ * @returns Capitalized string
+ */
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/package.json

@@ -2,7 +2,7 @@
 	"name": "@d34dman/flowdrop",
 	"license": "MIT",
 	"private": false,
-	"version": "0.0.16",
+	"version": "0.0.18",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",
@@ -136,4 +136,4 @@
 		"svelte-5-french-toast": "^2.0.6",
 		"uuid": "^11.1.0"
 	}
-}
+}