@d34dman/flowdrop 0.0.4 → 0.0.6

package/dist/helpers/workflowEditorHelper.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Workflow Editor Helper
+ * Contains business logic for workflow operations
+ */
+import type { WorkflowNode as WorkflowNodeType, NodeMetadata, Workflow, WorkflowEdge, NodeExecutionInfo } from '../types/index.js';
+import type { EndpointConfig } from '../config/endpoints.js';
+/**
+ * Edge styling configuration
+ */
+export declare class EdgeStylingHelper {
+    /**
+     * Apply custom styling to connection edges based on rules:
+     * - Dashed lines for connections to tool nodes
+     * - Arrow markers pointing towards input ports
+     */
+    static applyConnectionStyling(edge: WorkflowEdge, sourceNode: WorkflowNodeType, targetNode: WorkflowNodeType): void;
+    /**
+     * Update existing edges with custom styling rules
+     */
+    static updateEdgeStyles(edges: WorkflowEdge[], nodes: WorkflowNodeType[]): WorkflowEdge[];
+}
+/**
+ * Node operations helper
+ */
+export declare class NodeOperationsHelper {
+    /**
+     * Load nodes from API
+     */
+    static loadNodesFromApi(providedNodes?: NodeMetadata[]): Promise<NodeMetadata[]>;
+    /**
+     * Load node execution information for all nodes in the workflow
+     */
+    static loadNodeExecutionInfo(workflow: Workflow | null, pipelineId?: string): Promise<Record<string, NodeExecutionInfo>>;
+    /**
+     * Create a new node from dropped data
+     */
+    static createNodeFromDrop(nodeTypeData: string, position: {
+        x: number;
+        y: number;
+    }): WorkflowNodeType | null;
+}
+/**
+ * Workflow operations helper
+ */
+export declare class WorkflowOperationsHelper {
+    /**
+     * Generate workflow metadata for updates
+     */
+    static generateMetadata(existingMetadata?: Workflow['metadata']): Workflow['metadata'];
+    /**
+     * Update workflow with new nodes/edges and generate new metadata
+     */
+    static updateWorkflow(workflow: Workflow, nodes: WorkflowNodeType[], edges: WorkflowEdge[]): Workflow;
+    /**
+     * Clear workflow (remove all nodes and edges)
+     */
+    static clearWorkflow(workflow: Workflow): Workflow;
+    /**
+     * Update node configuration
+     */
+    static updateNodeConfig(workflow: Workflow, nodeId: string, newConfig: Record<string, unknown>): Workflow;
+    /**
+     * Add a new node to the workflow
+     */
+    static addNode(workflow: Workflow, node: WorkflowNodeType): Workflow;
+    /**
+     * Save workflow to backend
+     */
+    static saveWorkflow(workflow: Workflow | null): Promise<Workflow | null>;
+    /**
+     * Export workflow as JSON file
+     */
+    static exportWorkflow(workflow: Workflow | null): void;
+    /**
+     * Check if workflow has cycles
+     */
+    static checkWorkflowCycles(nodes: WorkflowNodeType[], edges: WorkflowEdge[]): boolean;
+}
+/**
+ * Configuration helper
+ */
+export declare class ConfigurationHelper {
+    /**
+     * Configure API endpoints
+     */
+    static configureEndpoints(config: EndpointConfig): void;
+}

package/dist/helpers/workflowEditorHelper.js

@@ -0,0 +1,365 @@
+/**
+ * Workflow Editor Helper
+ * Contains business logic for workflow operations
+ */
+import { MarkerType } from '@xyflow/svelte';
+import { hasCycles } from '../utils/connections.js';
+import { workflowApi, nodeApi, setEndpointConfig } from '../services/api.js';
+import { v4 as uuidv4 } from 'uuid';
+import { workflowActions } from '../stores/workflowStore.js';
+import { nodeExecutionService } from '../services/nodeExecutionService.js';
+/**
+ * Edge styling configuration
+ */
+export class EdgeStylingHelper {
+    /**
+     * Apply custom styling to connection edges based on rules:
+     * - Dashed lines for connections to tool nodes
+     * - Arrow markers pointing towards input ports
+     */
+    static applyConnectionStyling(edge, sourceNode, targetNode) {
+        // Rule 1: Dashed lines for tool nodes
+        // A node is a tool node when it uses the ToolNode component,
+        // which happens when sourceNode.type === "tool"
+        const isToolNode = sourceNode.type === 'tool';
+        // Use inline styles for dashed lines (more reliable than CSS classes)
+        if (isToolNode) {
+            edge.style = 'stroke-dasharray: 0 4 0; stroke: amber !important;';
+            edge.class = 'flowdrop--edge--tool';
+        }
+        else {
+            edge.style = 'stroke: grey;';
+        }
+        // Store metadata in edge data for debugging
+        edge.data = {
+            ...edge.data,
+            isToolConnection: isToolNode,
+            targetNodeType: targetNode.type,
+            targetCategory: targetNode.data.metadata.category
+        };
+        // Rule 2: Always add arrow pointing towards input port
+        // This replaces the default arrows we removed
+        if (!isToolNode) {
+            edge.markerEnd = {
+                type: MarkerType.ArrowClosed,
+                width: 16,
+                height: 16,
+                color: 'grey'
+            };
+        }
+    }
+    /**
+     * Update existing edges with custom styling rules
+     */
+    static updateEdgeStyles(edges, nodes) {
+        return edges.map((edge) => {
+            // Find source and target nodes
+            const sourceNode = nodes.find((node) => node.id === edge.source);
+            const targetNode = nodes.find((node) => node.id === edge.target);
+            if (!sourceNode || !targetNode) {
+                console.warn('Could not find nodes for edge:', edge.id);
+                return edge;
+            }
+            // Create a copy of the edge and apply styling
+            const updatedEdge = { ...edge };
+            this.applyConnectionStyling(updatedEdge, sourceNode, targetNode);
+            return updatedEdge;
+        });
+    }
+}
+/**
+ * Node operations helper
+ */
+export class NodeOperationsHelper {
+    /**
+     * Load nodes from API
+     */
+    static async loadNodesFromApi(providedNodes) {
+        // If nodes are provided via props, use them
+        if (providedNodes && providedNodes.length > 0) {
+            return providedNodes;
+        }
+        // Otherwise, load from API
+        try {
+            const fetchedNodes = await nodeApi.getNodes();
+            return fetchedNodes;
+        }
+        catch (error) {
+            console.error('❌ Failed to load nodes from API:', error);
+            // Use fallback sample nodes
+            return [
+                {
+                    id: 'text-input',
+                    name: 'Text Input',
+                    category: 'inputs',
+                    description: 'Simple text input field',
+                    version: '1.0.0',
+                    icon: 'mdi:text-box',
+                    inputs: [],
+                    outputs: [{ id: 'text', name: 'text', type: 'output', dataType: 'string' }]
+                },
+                {
+                    id: 'text-output',
+                    name: 'Text Output',
+                    category: 'outputs',
+                    description: 'Display text output',
+                    version: '1.0.0',
+                    icon: 'mdi:text-box-outline',
+                    inputs: [{ id: 'text', name: 'text', type: 'input', dataType: 'string' }],
+                    outputs: []
+                }
+            ];
+        }
+    }
+    /**
+     * Load node execution information for all nodes in the workflow
+     */
+    static async loadNodeExecutionInfo(workflow, pipelineId) {
+        if (!workflow?.nodes)
+            return {};
+        // Only load execution info if we have a pipelineId (for pipeline status mode)
+        if (!pipelineId)
+            return {};
+        try {
+            const nodeIds = workflow.nodes.map((node) => node.id);
+            const executionInfo = await nodeExecutionService.getMultipleNodeExecutionInfo(nodeIds, pipelineId);
+            return executionInfo;
+        }
+        catch (error) {
+            console.error('Failed to load node execution info:', error);
+            return {};
+        }
+    }
+    /**
+     * Create a new node from dropped data
+     */
+    static createNodeFromDrop(nodeTypeData, position) {
+        try {
+            const parsedData = JSON.parse(nodeTypeData);
+            // Handle both old format (with type: "node") and new format (direct NodeMetadata)
+            let nodeType;
+            let nodeData;
+            if (parsedData.type === 'node') {
+                // Old format from sidebar
+                nodeType = parsedData.nodeData.metadata;
+                nodeData = parsedData.nodeData;
+            }
+            else {
+                // New format (direct NodeMetadata)
+                nodeType = parsedData;
+                // Extract initial config from configSchema
+                let initialConfig = {};
+                if (nodeType.configSchema && typeof nodeType.configSchema === 'object') {
+                    // If configSchema is a JSON Schema, extract default values
+                    if (nodeType.configSchema.properties) {
+                        // JSON Schema format - extract defaults
+                        Object.entries(nodeType.configSchema.properties).forEach(([key, prop]) => {
+                            if (prop && typeof prop === 'object' && 'default' in prop) {
+                                initialConfig[key] = prop.default;
+                            }
+                        });
+                    }
+                    else {
+                        // Simple object format - use as is
+                        initialConfig = { ...nodeType.configSchema };
+                    }
+                }
+                nodeData = {
+                    label: nodeType.name,
+                    config: initialConfig,
+                    metadata: nodeType
+                };
+            }
+            const newNodeId = uuidv4();
+            // All nodes use "universalNode" type
+            // UniversalNode component handles internal switching based on metadata and config
+            const newNode = {
+                id: newNodeId,
+                type: 'universalNode',
+                position, // Use the position calculated from the drop event
+                deletable: true,
+                data: {
+                    ...nodeData,
+                    nodeId: newNodeId // Use the same ID
+                }
+            };
+            return newNode;
+        }
+        catch (error) {
+            console.error('Error parsing node data:', error);
+            return null;
+        }
+    }
+}
+/**
+ * Workflow operations helper
+ */
+export class WorkflowOperationsHelper {
+    /**
+     * Generate workflow metadata for updates
+     */
+    static generateMetadata(existingMetadata) {
+        return {
+            ...existingMetadata,
+            updatedAt: new Date().toISOString(),
+            versionId: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            updateNumber: (existingMetadata?.updateNumber || 0) + 1
+        };
+    }
+    /**
+     * Update workflow with new nodes/edges and generate new metadata
+     */
+    static updateWorkflow(workflow, nodes, edges) {
+        return {
+            ...workflow,
+            nodes,
+            edges,
+            metadata: this.generateMetadata(workflow.metadata)
+        };
+    }
+    /**
+     * Clear workflow (remove all nodes and edges)
+     */
+    static clearWorkflow(workflow) {
+        return {
+            ...workflow,
+            nodes: [],
+            edges: [],
+            metadata: this.generateMetadata(workflow.metadata)
+        };
+    }
+    /**
+     * Update node configuration
+     */
+    static updateNodeConfig(workflow, nodeId, newConfig) {
+        return {
+            ...workflow,
+            nodes: workflow.nodes.map((node) => node.id === nodeId
+                ? {
+                    ...node,
+                    data: { ...node.data, config: { ...newConfig } }
+                }
+                : node),
+            metadata: this.generateMetadata(workflow.metadata)
+        };
+    }
+    /**
+     * Add a new node to the workflow
+     */
+    static addNode(workflow, node) {
+        return {
+            ...workflow,
+            nodes: [...workflow.nodes, node],
+            metadata: this.generateMetadata(workflow.metadata)
+        };
+    }
+    /**
+     * Save workflow to backend
+     */
+    static async saveWorkflow(workflow) {
+        if (!workflow) {
+            console.warn('⚠️ No workflow data available to save');
+            return null;
+        }
+        try {
+            // Determine the workflow ID based on whether we have an existing workflow
+            let workflowId;
+            if (workflow.id) {
+                // Use the existing workflow ID
+                workflowId = workflow.id;
+            }
+            else {
+                // Generate a new UUID for a new workflow
+                workflowId = uuidv4();
+            }
+            const workflowToSave = {
+                id: workflowId,
+                name: workflow.name || 'Untitled Workflow',
+                nodes: workflow.nodes || [],
+                edges: workflow.edges || [],
+                metadata: {
+                    version: '1.0.0',
+                    createdAt: workflow.metadata?.createdAt || new Date().toISOString(),
+                    updatedAt: new Date().toISOString()
+                }
+            };
+            console.log('💾 WorkflowEditor: Saving workflow to backend:');
+            console.log('   - ID:', workflowToSave.id);
+            console.log('   - Name:', workflowToSave.name);
+            console.log('   - Nodes count:', workflowToSave.nodes.length);
+            console.log('   - Edges count:', workflowToSave.edges.length);
+            console.log('   - Full workflow object:', JSON.stringify(workflowToSave, null, 2));
+            const savedWorkflow = await workflowApi.saveWorkflow(workflowToSave);
+            console.log('✅ WorkflowEditor: Received workflow from backend:');
+            console.log('   - ID:', savedWorkflow.id);
+            console.log('   - Name:', savedWorkflow.name);
+            console.log('   - Nodes count:', savedWorkflow.nodes?.length || 0);
+            console.log('   - Edges count:', savedWorkflow.edges?.length || 0);
+            // Update the workflow ID if it changed (new workflow)
+            if (savedWorkflow.id && savedWorkflow.id !== workflowToSave.id) {
+                console.log('🔄 Updating workflow ID from', workflowToSave.id, 'to', savedWorkflow.id);
+                workflowActions.batchUpdate({
+                    nodes: workflowToSave.nodes,
+                    edges: workflowToSave.edges,
+                    name: workflowToSave.name,
+                    metadata: {
+                        ...workflowToSave.metadata,
+                        ...savedWorkflow.metadata
+                    }
+                });
+            }
+            return savedWorkflow;
+        }
+        catch (error) {
+            console.error('❌ Failed to save workflow:', error);
+            throw error;
+        }
+    }
+    /**
+     * Export workflow as JSON file
+     */
+    static exportWorkflow(workflow) {
+        if (!workflow) {
+            console.warn('⚠️ No workflow data available to export');
+            return;
+        }
+        // Use the same ID logic as saveWorkflow
+        const workflowId = workflow.id || uuidv4();
+        const workflowToExport = {
+            id: workflowId,
+            name: workflow.name || 'Untitled Workflow',
+            nodes: workflow.nodes || [],
+            edges: workflow.edges || [],
+            metadata: {
+                version: '1.0.0',
+                createdAt: workflow.metadata?.createdAt || new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            }
+        };
+        const dataStr = JSON.stringify(workflowToExport, null, 2);
+        const dataBlob = new Blob([dataStr], { type: 'application/json' });
+        const url = URL.createObjectURL(dataBlob);
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = `${workflowToExport.name}.json`;
+        link.click();
+        URL.revokeObjectURL(url);
+    }
+    /**
+     * Check if workflow has cycles
+     */
+    static checkWorkflowCycles(nodes, edges) {
+        return hasCycles(nodes, edges);
+    }
+}
+/**
+ * Configuration helper
+ */
+export class ConfigurationHelper {
+    /**
+     * Configure API endpoints
+     */
+    static configureEndpoints(config) {
+        setEndpointConfig(config);
+    }
+}

package/dist/index.d.ts

@@ -2,7 +2,7 @@
  * FlowDrop - Visual Workflow Editor Library
  * A Svelte 5 component library built on @xyflow/svelte for creating node-based workflow editors
  */
-import "./styles/base.css";
+import './styles/base.css';
 export type { NodeCategory, NodeDataType, NodePort, NodeMetadata, NodeConfig, WorkflowNode, WorkflowEdge, Workflow, ApiResponse, NodesResponse, WorkflowResponse, WorkflowsResponse, ExecutionStatus, ExecutionResult, FlowDropConfig, WorkflowEvents } from './types/index.js';
 export type { WorkflowEditorConfig, EditorFeatures, UIConfig, APIConfig, ExecutionConfig, StorageConfig, NodeType, WorkflowData, ExecutionResult as EditorExecutionResult, EditorState } from './types/config.js';
 export { FlowDropApiClient } from './api/client.js';
@@ -14,14 +14,44 @@ export { default as SimpleNodeComponent } from './components/SimpleNode.svelte';
 export { default as ToolNodeComponent } from './components/ToolNode.svelte';
 export { default as NotesNodeComponent } from './components/NotesNode.svelte';
 export { default as CanvasBanner } from './components/CanvasBanner.svelte';
+export { default as UniversalNode } from './components/UniversalNode.svelte';
+export { default as GatewayNode } from './components/GatewayNode.svelte';
+export { default as SquareNode } from './components/SquareNode.svelte';
+export { default as LoadingSpinner } from './components/LoadingSpinner.svelte';
+export { default as StatusIcon } from './components/StatusIcon.svelte';
+export { default as StatusLabel } from './components/StatusLabel.svelte';
+export { default as NodeStatusOverlay } from './components/NodeStatusOverlay.svelte';
+export { default as MarkdownDisplay } from './components/MarkdownDisplay.svelte';
+export { default as ConfigForm } from './components/ConfigForm.svelte';
+export { default as ConfigModal } from './components/ConfigModal.svelte';
+export { default as ConfigSidebar } from './components/ConfigSidebar.svelte';
+export { default as ConnectionLine } from './components/ConnectionLine.svelte';
+export { default as LogsSidebar } from './components/LogsSidebar.svelte';
+export { default as PipelineStatus } from './components/PipelineStatus.svelte';
+export { default as Navbar } from './components/Navbar.svelte';
+export { default as Logo } from './components/Logo.svelte';
 export { sampleNodes, sampleWorkflow } from './data/samples.js';
 export * from './utils/icons.js';
 export * from './utils/colors.js';
 export * from './utils/connections.js';
 export * from './utils/config.js';
 export * from './utils/nodeTypes.js';
+export { getStatusColor, getStatusIcon, getStatusLabel, getStatusBackgroundColor, getStatusTextColor, createDefaultExecutionInfo, updateExecutionStart, updateExecutionComplete, updateExecutionFailed, resetExecutionInfo, formatExecutionDuration, formatLastExecuted } from './utils/nodeStatus.js';
+export { createNodeWrapperConfig, shouldShowNodeStatus, getOptimalStatusPosition, getOptimalStatusSize, DEFAULT_NODE_STATUS_CONFIG } from './utils/nodeWrapper.js';
+export type { NodeStatusConfig } from './utils/nodeWrapper.js';
 export * from './services/api.js';
+export { showSuccess, showError, showWarning, showInfo, showLoading, dismissToast, dismissAllToasts, showPromise, showConfirmation, apiToasts, workflowToasts, pipelineToasts } from './services/toastService.js';
+export type { ToastType, ToastOptions } from './services/toastService.js';
+export { NodeExecutionService, nodeExecutionService } from './services/nodeExecutionService.js';
+export { saveWorkflow, updateWorkflow, getWorkflow, getWorkflows, deleteWorkflow, getWorkflowCount, initializeSampleWorkflows } from './services/workflowStorage.js';
+export { globalSaveWorkflow, globalExportWorkflow, initializeGlobalSave } from './services/globalSave.js';
+export { fetchPortConfig, validatePortConfig } from './services/portConfigApi.js';
+export { EdgeStylingHelper, NodeOperationsHelper, WorkflowOperationsHelper, ConfigurationHelper } from './helpers/workflowEditorHelper.js';
+export { workflowStore, workflowActions, workflowId, workflowName, workflowNodes, workflowEdges, workflowMetadata, workflowChanged, workflowValidation, workflowMetadataChanged } from './stores/workflowStore.js';
 export * from './config/endpoints.js';
+export { defaultApiConfig, getEndpointUrl } from './config/apiConfig.js';
+export type { ApiConfig } from './config/apiConfig.js';
+export { DEFAULT_PORT_CONFIG } from './config/defaultPortConfig.js';
 export * from './adapters/WorkflowAdapter.js';
 export * from './clients/ApiClient.js';
 export { mountWorkflowEditor, unmountWorkflowEditor, mountFlowDropApp, unmountFlowDropApp } from './svelte-app.js';

package/dist/index.js

@@ -3,7 +3,7 @@
  * A Svelte 5 component library built on @xyflow/svelte for creating node-based workflow editors
  */
 // Import CSS to ensure styles are included in the library build
-import "./styles/base.css";
+import './styles/base.css';
 // Export API clients
 export { FlowDropApiClient } from './api/client.js';
 export { EnhancedFlowDropApiClient } from './api/enhanced-client.js';
@@ -15,6 +15,22 @@ export { default as SimpleNodeComponent } from './components/SimpleNode.svelte';
 export { default as ToolNodeComponent } from './components/ToolNode.svelte';
 export { default as NotesNodeComponent } from './components/NotesNode.svelte';
 export { default as CanvasBanner } from './components/CanvasBanner.svelte';
+export { default as UniversalNode } from './components/UniversalNode.svelte';
+export { default as GatewayNode } from './components/GatewayNode.svelte';
+export { default as SquareNode } from './components/SquareNode.svelte';
+export { default as LoadingSpinner } from './components/LoadingSpinner.svelte';
+export { default as StatusIcon } from './components/StatusIcon.svelte';
+export { default as StatusLabel } from './components/StatusLabel.svelte';
+export { default as NodeStatusOverlay } from './components/NodeStatusOverlay.svelte';
+export { default as MarkdownDisplay } from './components/MarkdownDisplay.svelte';
+export { default as ConfigForm } from './components/ConfigForm.svelte';
+export { default as ConfigModal } from './components/ConfigModal.svelte';
+export { default as ConfigSidebar } from './components/ConfigSidebar.svelte';
+export { default as ConnectionLine } from './components/ConnectionLine.svelte';
+export { default as LogsSidebar } from './components/LogsSidebar.svelte';
+export { default as PipelineStatus } from './components/PipelineStatus.svelte';
+export { default as Navbar } from './components/Navbar.svelte';
+export { default as Logo } from './components/Logo.svelte';
 // Export sample data for development
 export { sampleNodes, sampleWorkflow } from './data/samples.js';
 // Export utilities
@@ -23,10 +39,23 @@ export * from './utils/colors.js';
 export * from './utils/connections.js';
 export * from './utils/config.js';
 export * from './utils/nodeTypes.js';
+export { getStatusColor, getStatusIcon, getStatusLabel, getStatusBackgroundColor, getStatusTextColor, createDefaultExecutionInfo, updateExecutionStart, updateExecutionComplete, updateExecutionFailed, resetExecutionInfo, formatExecutionDuration, formatLastExecuted } from './utils/nodeStatus.js';
+export { createNodeWrapperConfig, shouldShowNodeStatus, getOptimalStatusPosition, getOptimalStatusSize, DEFAULT_NODE_STATUS_CONFIG } from './utils/nodeWrapper.js';
 // Export services
 export * from './services/api.js';
+export { showSuccess, showError, showWarning, showInfo, showLoading, dismissToast, dismissAllToasts, showPromise, showConfirmation, apiToasts, workflowToasts, pipelineToasts } from './services/toastService.js';
+export { NodeExecutionService, nodeExecutionService } from './services/nodeExecutionService.js';
+export { saveWorkflow, updateWorkflow, getWorkflow, getWorkflows, deleteWorkflow, getWorkflowCount, initializeSampleWorkflows } from './services/workflowStorage.js';
+export { globalSaveWorkflow, globalExportWorkflow, initializeGlobalSave } from './services/globalSave.js';
+export { fetchPortConfig, validatePortConfig } from './services/portConfigApi.js';
+// Export helpers
+export { EdgeStylingHelper, NodeOperationsHelper, WorkflowOperationsHelper, ConfigurationHelper } from './helpers/workflowEditorHelper.js';
+// Export stores
+export { workflowStore, workflowActions, workflowId, workflowName, workflowNodes, workflowEdges, workflowMetadata, workflowChanged, workflowValidation, workflowMetadataChanged } from './stores/workflowStore.js';
 // Export endpoint configuration
 export * from './config/endpoints.js';
+export { defaultApiConfig, getEndpointUrl } from './config/apiConfig.js';
+export { DEFAULT_PORT_CONFIG } from './config/defaultPortConfig.js';
 // Export adapters
 export * from './adapters/WorkflowAdapter.js';
 // Export API client

package/dist/mocks/app-navigation.d.ts

@@ -1,5 +1,5 @@
-export function goto(url: any, options?: {}): Promise<void>;
-export function invalidate(url: any): Promise<void>;
+export function goto(): Promise<void>;
+export function invalidate(): Promise<void>;
 export function invalidateAll(): Promise<void>;
-export function preloadData(url: any): Promise<{}>;
-export function preloadCode(url: any): Promise<void>;
+export function preloadData(): Promise<{}>;
+export function preloadCode(): Promise<void>;

package/dist/mocks/app-navigation.js

@@ -4,13 +4,13 @@
  */
 
 // Mock goto function
-export const goto = async (url, options = {}) => {
+export const goto = async () => {
 	// No-op for library context
 	console.warn('Navigation not available in library context');
 };
 
 // Mock invalidate function
-export const invalidate = async (url) => {
+export const invalidate = async () => {
 	// No-op for library context
 	return Promise.resolve();
 };
@@ -22,13 +22,13 @@ export const invalidateAll = async () => {
 };
 
 // Mock preloadData function
-export const preloadData = async (url) => {
+export const preloadData = async () => {
 	// No-op for library context
 	return Promise.resolve({});
 };
 
 // Mock preloadCode function
-export const preloadCode = async (url) => {
+export const preloadCode = async () => {
 	// No-op for library context
 	return Promise.resolve();
 };

package/dist/services/api.js

@@ -28,7 +28,7 @@ export function setApiBaseUrl(url) {
             .then(({ createEndpointConfig }) => {
             endpointConfig = createEndpointConfig(url);
         })
-            .catch((error) => {
+            .catch(() => {
             // Failed to load endpoint config
         });
     }
@@ -43,24 +43,19 @@ async function apiRequest(endpointKey, endpointPath, params, options = {}) {
     if (!endpointConfig) {
         throw new Error('Endpoint configuration not set. Call setEndpointConfig() first.');
     }
-    try {
-        const url = buildEndpointUrl(endpointConfig, endpointPath, params);
-        const method = getEndpointMethod(endpointConfig, endpointKey);
-        const headers = getEndpointHeaders(endpointConfig, endpointKey);
-        const response = await fetch(url, {
-            method,
-            headers,
-            ...options
-        });
-        const data = await response.json();
-        if (!response.ok) {
-            throw new Error(data.error || `HTTP ${response.status}: ${response.statusText}`);
-        }
-        return data;
-    }
-    catch (error) {
-        throw error;
+    const url = buildEndpointUrl(endpointConfig, endpointPath, params);
+    const method = getEndpointMethod(endpointConfig, endpointKey);
+    const headers = getEndpointHeaders(endpointConfig, endpointKey);
+    const response = await fetch(url, {
+        method,
+        headers,
+        ...options
+    });
+    const data = await response.json();
+    if (!response.ok) {
+        throw new Error(data.error || `HTTP ${response.status}: ${response.statusText}`);
     }
+    return data;
 }
 /**
  * Node API methods