@d34dman/flowdrop 0.0.15 → 0.0.17

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',
@@ -14,14 +24,43 @@ const NODE_TYPE_TO_COMPONENT_MAP = {
     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)',
+    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 +72,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 +214,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.15",
+	"version": "0.0.17",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",
@@ -93,7 +93,6 @@
 		"@eslint/js": "^9.18.0",
 		"@iconify/svelte": "^5.0.0",
 		"@playwright/test": "^1.49.1",
-		"@storybook/addon-a11y": "^9.0.15",
 		"@storybook/addon-docs": "^9.0.15",
 		"@storybook/addon-svelte-csf": "^5.0.4",
 		"@storybook/addon-vitest": "^9.0.15",