@d34dman/flowdrop 0.0.1

package/dist/utils/connections.js

@@ -0,0 +1,240 @@
+/**
+ * Connection validation utilities for FlowDrop
+ */
+/**
+ * Check if two data types are compatible for connection
+ */
+export function areDataTypesCompatible(outputType, inputType) {
+    // Direct type matches
+    if (outputType === inputType)
+        return true;
+    // String can be converted to most types
+    if (outputType === "string") {
+        return ["string", "number", "boolean"].includes(inputType);
+    }
+    // Number can be converted to string
+    if (outputType === "number") {
+        return ["string", "number"].includes(inputType);
+    }
+    // Boolean can be converted to string
+    if (outputType === "boolean") {
+        return ["string", "boolean"].includes(inputType);
+    }
+    // Object can be converted to string (JSON)
+    if (outputType === "object") {
+        return ["string", "object"].includes(inputType);
+    }
+    // Array can be converted to string (JSON)
+    if (outputType === "array") {
+        return ["string", "array"].includes(inputType);
+    }
+    return false;
+}
+/**
+ * Get all possible connections from a source node to target nodes
+ */
+export function getPossibleConnections(sourceNode, targetNodes, nodeTypes) {
+    const sourceMetadata = nodeTypes.find(nt => nt.id === sourceNode.data.metadata.id);
+    if (!sourceMetadata)
+        return [];
+    const possibleConnections = [];
+    // Get all output ports from source node
+    const sourceOutputs = sourceMetadata.outputs;
+    // Check each target node
+    for (const targetNode of targetNodes) {
+        if (targetNode.id === sourceNode.id)
+            continue; // Skip self-connection
+        const targetMetadata = nodeTypes.find(nt => nt.id === targetNode.data.metadata.id);
+        if (!targetMetadata)
+            continue;
+        // Get all input ports from target node
+        const targetInputs = targetMetadata.inputs;
+        // Check each output-input combination
+        for (const sourcePort of sourceOutputs) {
+            for (const targetPort of targetInputs) {
+                const compatible = areDataTypesCompatible(sourcePort.dataType, targetPort.dataType);
+                possibleConnections.push({
+                    sourceNodeId: sourceNode.id,
+                    sourcePortId: sourcePort.id,
+                    sourcePort,
+                    targetNodeId: targetNode.id,
+                    targetPortId: targetPort.id,
+                    targetPort,
+                    compatible
+                });
+            }
+        }
+    }
+    return possibleConnections;
+}
+/**
+ * Validate if a specific connection is valid
+ */
+export function validateConnection(sourceNodeId, sourcePortId, targetNodeId, targetPortId, nodes, nodeTypes) {
+    // Check if nodes exist
+    const sourceNode = nodes.find(n => n.id === sourceNodeId);
+    const targetNode = nodes.find(n => n.id === targetNodeId);
+    if (!sourceNode) {
+        return { valid: false, error: "Source node not found" };
+    }
+    if (!targetNode) {
+        return { valid: false, error: "Target node not found" };
+    }
+    // Check for self-connection
+    if (sourceNodeId === targetNodeId) {
+        return { valid: false, error: "Cannot connect node to itself" };
+    }
+    // Get node metadata
+    const sourceMetadata = nodeTypes.find(nt => nt.id === sourceNode.data.metadata.id);
+    const targetMetadata = nodeTypes.find(nt => nt.id === targetNode.data.metadata.id);
+    if (!sourceMetadata || !targetMetadata) {
+        console.log("Metadata lookup failed:", {
+            sourceNodeId,
+            targetNodeId,
+            sourceMetadataId: sourceNode.data.metadata.id,
+            targetMetadataId: targetNode.data.metadata.id,
+            availableNodeTypes: nodeTypes.map(nt => nt.id)
+        });
+        return { valid: false, error: "Node metadata not found" };
+    }
+    // Find ports
+    const sourcePort = sourceMetadata.outputs.find(p => p.id === sourcePortId);
+    const targetPort = targetMetadata.inputs.find(p => p.id === targetPortId);
+    if (!sourcePort) {
+        return { valid: false, error: "Source port not found" };
+    }
+    if (!targetPort) {
+        return { valid: false, error: "Target port not found" };
+    }
+    // Check data type compatibility
+    if (!areDataTypesCompatible(sourcePort.dataType, targetPort.dataType)) {
+        return {
+            valid: false,
+            error: `Incompatible data types: ${sourcePort.dataType} cannot connect to ${targetPort.dataType}`
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Get connection suggestions for a node
+ */
+export function getConnectionSuggestions(nodeId, nodes, nodeTypes) {
+    const node = nodes.find(n => n.id === nodeId);
+    if (!node)
+        return [];
+    const metadata = nodeTypes.find(nt => nt.id === node.data.metadata.id);
+    if (!metadata)
+        return [];
+    const suggestions = [];
+    // Get all other nodes
+    const otherNodes = nodes.filter(n => n.id !== nodeId);
+    for (const otherNode of otherNodes) {
+        const otherMetadata = nodeTypes.find(nt => nt.id === otherNode.data.metadata.id);
+        if (!otherMetadata)
+            continue;
+        // Check outputs from other nodes to inputs of current node
+        for (const output of otherMetadata.outputs) {
+            for (const input of metadata.inputs) {
+                const compatible = areDataTypesCompatible(output.dataType, input.dataType);
+                suggestions.push({
+                    nodeId: otherNode.id,
+                    nodeName: otherNode.data.label,
+                    portId: output.id,
+                    portName: output.name,
+                    portType: "output",
+                    dataType: output.dataType,
+                    compatible
+                });
+            }
+        }
+        // Check outputs from current node to inputs of other nodes
+        for (const output of metadata.outputs) {
+            for (const input of otherMetadata.inputs) {
+                const compatible = areDataTypesCompatible(output.dataType, input.dataType);
+                suggestions.push({
+                    nodeId: otherNode.id,
+                    nodeName: otherNode.data.label,
+                    portId: input.id,
+                    portName: input.name,
+                    portType: "input",
+                    dataType: input.dataType,
+                    compatible
+                });
+            }
+        }
+    }
+    return suggestions;
+}
+/**
+ * Check if a workflow has any cycles (prevent infinite loops)
+ */
+export function hasCycles(nodes, edges) {
+    const visited = new Set();
+    const recursionStack = new Set();
+    function hasCycleUtil(nodeId) {
+        if (recursionStack.has(nodeId))
+            return true;
+        if (visited.has(nodeId))
+            return false;
+        visited.add(nodeId);
+        recursionStack.add(nodeId);
+        // Get all outgoing edges from this node
+        const outgoingEdges = edges.filter(e => e.source === nodeId);
+        for (const edge of outgoingEdges) {
+            if (hasCycleUtil(edge.target))
+                return true;
+        }
+        recursionStack.delete(nodeId);
+        return false;
+    }
+    // Check each node
+    for (const node of nodes) {
+        if (!visited.has(node.id)) {
+            if (hasCycleUtil(node.id))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Get the execution order for a workflow (topological sort)
+ */
+export function getExecutionOrder(nodes, edges) {
+    const inDegree = new Map();
+    const graph = new Map();
+    // Initialize
+    for (const node of nodes) {
+        inDegree.set(node.id, 0);
+        graph.set(node.id, []);
+    }
+    // Build graph and calculate in-degrees
+    for (const edge of edges) {
+        const current = inDegree.get(edge.target) || 0;
+        inDegree.set(edge.target, current + 1);
+        const neighbors = graph.get(edge.source) || [];
+        neighbors.push(edge.target);
+        graph.set(edge.source, neighbors);
+    }
+    // Topological sort
+    const queue = [];
+    const result = [];
+    // Add nodes with no incoming edges
+    for (const [nodeId, degree] of inDegree) {
+        if (degree === 0) {
+            queue.push(nodeId);
+        }
+    }
+    while (queue.length > 0) {
+        const nodeId = queue.shift();
+        result.push(nodeId);
+        const neighbors = graph.get(nodeId) || [];
+        for (const neighbor of neighbors) {
+            const degree = inDegree.get(neighbor) - 1;
+            inDegree.set(neighbor, degree);
+            if (degree === 0) {
+                queue.push(neighbor);
+            }
+        }
+    }
+    return result;
+}

package/dist/utils/icons.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Centralized icon management for FlowDrop
+ * Ensures consistent icon usage across all components
+ */
+import type { NodeCategory } from "../types/index.js";
+/**
+ * Default icons for different contexts
+ */
+export declare const DEFAULT_ICONS: {
+    readonly NODE: "mdi:cube";
+    readonly CATEGORY: "mdi:folder";
+    readonly ADD: "mdi:plus";
+    readonly REMOVE: "mdi:minus";
+    readonly EDIT: "mdi:pencil";
+    readonly SAVE: "mdi:content-save";
+    readonly LOAD: "mdi:folder-open";
+    readonly EXPORT: "mdi:download";
+    readonly IMPORT: "mdi:upload";
+    readonly SEARCH: "mdi:magnify";
+    readonly CLOSE: "mdi:close";
+    readonly SETTINGS: "mdi:cog";
+    readonly HELP: "mdi:help-circle";
+    readonly SUCCESS: "mdi:check-circle";
+    readonly ERROR: "mdi:alert-circle";
+    readonly WARNING: "mdi:alert";
+    readonly INFO: "mdi:information";
+    readonly LOADING: "mdi:loading";
+    readonly HOME: "mdi:home";
+    readonly BACK: "mdi:arrow-left";
+    readonly FORWARD: "mdi:arrow-right";
+    readonly UP: "mdi:arrow-up";
+    readonly DOWN: "mdi:arrow-down";
+    readonly WORKFLOW: "mdi:graph";
+    readonly NODE_ADD: "mdi:plus-circle";
+    readonly NODE_DELETE: "mdi:minus-circle";
+    readonly CONNECTION: "mdi:connection";
+    readonly DATA: "mdi:database";
+    readonly FILE: "mdi:file";
+    readonly TEXT: "mdi:text";
+    readonly JSON: "mdi:code-json";
+    readonly MODEL: "mdi:chip";
+    readonly BRAIN: "mdi:brain";
+    readonly VECTOR: "mdi:vector-point";
+    readonly ROBOT: "mdi:robot";
+    readonly TOOL: "mdi:wrench";
+    readonly CALCULATOR: "mdi:calculator";
+    readonly CLOCK: "mdi:clock";
+    readonly CHAT: "mdi:chat";
+    readonly MESSAGE: "mdi:message";
+    readonly EMAIL: "mdi:email";
+    readonly WEBHOOK: "mdi:webhook";
+    readonly STORAGE: "mdi:database";
+    readonly MEMORY: "mdi:memory";
+    readonly CACHE: "mdi:cached";
+    readonly PROCESS: "mdi:cog";
+    readonly FILTER: "mdi:filter";
+    readonly SORT: "mdi:sort";
+    readonly TRANSFORM: "mdi:transform";
+    readonly LOGIC: "mdi:git-branch";
+    readonly CONDITION: "mdi:source-fork";
+    readonly LOOP: "mdi:loop";
+    readonly API: "mdi:api";
+    readonly LINK: "mdi:link";
+    readonly PLUGIN: "mdi:puzzle";
+    readonly BUNDLE: "mdi:package-variant";
+};
+/**
+ * Category-specific icons matching Langflow's visual style
+ */
+export declare const CATEGORY_ICONS: Record<NodeCategory, string>;
+/**
+ * Get the appropriate icon for a node
+ * @param nodeIcon - The node's specific icon
+ * @param category - The node's category
+ * @returns The icon to use
+ */
+export declare function getNodeIcon(nodeIcon?: string, category?: NodeCategory): string;
+/**
+ * Get the appropriate icon for a category
+ * @param category - The category
+ * @returns The icon to use
+ */
+export declare function getCategoryIcon(category: NodeCategory): string;
+/**
+ * Get a default icon by key
+ * @param key - The icon key from DEFAULT_ICONS
+ * @returns The icon string
+ */
+export declare function getDefaultIcon(key: keyof typeof DEFAULT_ICONS): string;
+/**
+ * Validate if an icon string is properly formatted
+ * @param icon - The icon string to validate
+ * @returns True if valid, false otherwise
+ */
+export declare function isValidIcon(icon: string): boolean;
+/**
+ * Get a fallback icon if the provided icon is invalid
+ * @param icon - The icon to check
+ * @param fallback - The fallback icon to use
+ * @returns The valid icon string
+ */
+export declare function getValidIcon(icon: string, fallback?: string): string;

package/dist/utils/icons.js

@@ -0,0 +1,149 @@
+/**
+ * Centralized icon management for FlowDrop
+ * Ensures consistent icon usage across all components
+ */
+/**
+ * Default icons for different contexts
+ */
+export const DEFAULT_ICONS = {
+    // Node fallback icons
+    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",
+    // Status icons
+    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",
+    // Workflow icons
+    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",
+    // Model and processing icons
+    MODEL: "mdi:chip",
+    BRAIN: "mdi:brain",
+    VECTOR: "mdi:vector-point",
+    ROBOT: "mdi:robot",
+    // Tool icons
+    TOOL: "mdi:wrench",
+    CALCULATOR: "mdi:calculator",
+    CLOCK: "mdi:clock",
+    // Communication icons
+    CHAT: "mdi:chat",
+    MESSAGE: "mdi:message",
+    EMAIL: "mdi:email",
+    WEBHOOK: "mdi:webhook",
+    // Storage icons
+    STORAGE: "mdi:database",
+    MEMORY: "mdi:memory",
+    CACHE: "mdi:cached",
+    // Processing icons
+    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",
+    // Integration icons
+    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"
+};
+/**
+ * Get the appropriate icon for a node
+ * @param nodeIcon - The node's specific icon
+ * @param category - The node's category
+ * @returns The icon to use
+ */
+export function getNodeIcon(nodeIcon, category) {
+    // If node has a specific icon, use it
+    if (nodeIcon) {
+        return nodeIcon;
+    }
+    // If category is provided, use category icon
+    if (category && CATEGORY_ICONS[category]) {
+        return CATEGORY_ICONS[category];
+    }
+    // Fallback to default node icon
+    return DEFAULT_ICONS.NODE;
+}
+/**
+ * Get the appropriate icon for a category
+ * @param category - The category
+ * @returns The icon to use
+ */
+export function getCategoryIcon(category) {
+    return CATEGORY_ICONS[category] || DEFAULT_ICONS.CATEGORY;
+}
+/**
+ * Get a default icon by key
+ * @param key - The icon key from DEFAULT_ICONS
+ * @returns The icon string
+ */
+export function getDefaultIcon(key) {
+    return DEFAULT_ICONS[key];
+}
+/**
+ * Validate if an icon string is properly formatted
+ * @param icon - The icon string to validate
+ * @returns True if valid, false otherwise
+ */
+export function isValidIcon(icon) {
+    // Check if it's a valid iconify format (e.g., "mdi:icon-name")
+    return /^[a-z-]+:[a-z-]+$/.test(icon);
+}
+/**
+ * Get a fallback icon if the provided icon is invalid
+ * @param icon - The icon to check
+ * @param fallback - The fallback icon to use
+ * @returns The valid icon string
+ */
+export function getValidIcon(icon, fallback = DEFAULT_ICONS.NODE) {
+    return isValidIcon(icon) ? icon : fallback;
+}

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@d34dman/flowdrop",
+  "version": "0.0.1",
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build && npm run prepack",
+    "watch:build": "npm-watch build",
+    "preview": "vite preview",
+    "prepare": "svelte-kit sync || echo ''",
+    "prepack": "svelte-kit sync && svelte-package && publint",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "lint": "eslint . && prettier --check .",
+    "test:unit": "vitest",
+    "test": "npm run test:unit -- --run && npm run test:e2e",
+    "test:e2e": "playwright test",
+    "format": "prettier --write .",
+    "storybook": "storybook dev -p 6006",
+    "build-storybook": "storybook build"
+  },
+  "watch": {
+    "build": {
+      "ignore": "build",
+      "patterns": [
+        "src"
+      ],
+      "extensions": "js,ts,svelte,html,css,svg",
+      "quiet": true,
+      "legacyWatch": true,
+      "delay": 2500,
+      "runOnChangeOnly": false
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js"
+    }
+  },
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  },
+  "devDependencies": {
+    "@chromatic-com/storybook": "^4.0.1",
+    "@eslint/compat": "^1.2.5",
+    "@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",
+    "@storybook/sveltekit": "^9.0.15",
+    "@sveltejs/adapter-auto": "^6.0.0",
+    "@sveltejs/kit": "^2.16.0",
+    "@sveltejs/package": "^2.0.0",
+    "@sveltejs/vite-plugin-svelte": "^5.0.0",
+    "@types/node": "^20",
+    "@vitest/browser": "^3.2.3",
+    "eslint": "^9.18.0",
+    "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-storybook": "^9.0.15",
+    "eslint-plugin-svelte": "^3.0.0",
+    "globals": "^16.0.0",
+    "playwright": "^1.53.0",
+    "prettier": "^3.4.2",
+    "prettier-plugin-svelte": "^3.3.3",
+    "publint": "^0.3.2",
+    "storybook": "^9.0.15",
+    "svelte": "^5.0.0",
+    "svelte-check": "^4.0.0",
+    "terser": "^5.43.1",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.20.0",
+    "vite": "^6.2.6",
+    "vite-plugin-devtools-json": "^0.2.1",
+    "vitest": "^3.2.3",
+    "vitest-browser-svelte": "^0.1.0"
+  },
+  "keywords": [
+    "svelte"
+  ],
+  "dependencies": {
+    "@types/uuid": "^10.0.0",
+    "@xyflow/svelte": "~1.2",
+    "uuid": "^11.1.0"
+  }
+}