@flowdrop/flowdrop 1.15.0 → 2.0.0-beta.2

package/dist/registry/plugin.js

@@ -1,249 +0,0 @@
-/**
- * FlowDrop Plugin System
- * Provides APIs for external libraries to register custom node components.
- *
- * This enables a plugin ecosystem where:
- * - Third-party libraries can provide custom node types
- * - Custom nodes are namespaced to avoid conflicts
- * - Registration is simplified with a clean API
- */
-import { nodeComponentRegistry, createNamespacedType } from './nodeComponentRegistry.js';
-/**
- * Register a FlowDrop plugin with custom node components.
- * All node types are automatically namespaced with the plugin namespace.
- *
- * @param config - Plugin configuration with namespace and node definitions
- * @returns Result object with registered types and any errors
- *
- * @example
- * ```typescript
- * import { registerFlowDropPlugin } from "@flowdrop/lib";
- * import FancyNode from "./FancyNode.svelte";
- * import GlowNode from "./GlowNode.svelte";
- *
- * const result = registerFlowDropPlugin({
- *     namespace: "awesome",
- *     name: "Awesome Nodes",
- *     version: "1.0.0",
- *     nodes: [
- *         {
- *             type: "fancy",
- *             displayName: "Fancy Node",
- *             component: FancyNode,
- *             icon: "mdi:sparkles"
- *         },
- *         {
- *             type: "glow",
- *             displayName: "Glowing Node",
- *             component: GlowNode,
- *             icon: "mdi:lightbulb"
- *         }
- *     ]
- * });
- *
- * // Result:
- * // {
- * //     success: true,
- * //     namespace: "awesome",
- * //     registeredTypes: ["awesome:fancy", "awesome:glow"],
- * //     errors: []
- * // }
- * ```
- */
-export function registerFlowDropPlugin(config) {
-    const result = {
-        success: true,
-        namespace: config.namespace,
-        registeredTypes: [],
-        errors: []
-    };
-    // Validate namespace
-    if (!isValidNamespace(config.namespace)) {
-        result.success = false;
-        result.errors.push(`Invalid namespace "${config.namespace}". ` +
-            `Namespace must be lowercase alphanumeric with optional hyphens.`);
-        return result;
-    }
-    // Register each node
-    for (const nodeDef of config.nodes) {
-        try {
-            const namespacedType = createNamespacedType(config.namespace, nodeDef.type);
-            const registration = {
-                type: namespacedType,
-                displayName: nodeDef.displayName,
-                description: nodeDef.description,
-                component: nodeDef.component,
-                icon: nodeDef.icon,
-                category: nodeDef.category ?? 'custom',
-                source: config.namespace,
-                statusPosition: nodeDef.statusPosition,
-                statusSize: nodeDef.statusSize
-            };
-            nodeComponentRegistry.register(registration);
-            result.registeredTypes.push(namespacedType);
-        }
-        catch (error) {
-            result.success = false;
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            result.errors.push(`Failed to register ${config.namespace}:${nodeDef.type}: ${errorMessage}`);
-        }
-    }
-    return result;
-}
-/**
- * Unregister all nodes from a plugin by namespace.
- *
- * @param namespace - The plugin namespace to unregister
- * @returns Array of unregistered type identifiers
- *
- * @example
- * ```typescript
- * const removed = unregisterFlowDropPlugin("awesome");
- * // Returns ["awesome:fancy", "awesome:glow"]
- * ```
- */
-export function unregisterFlowDropPlugin(namespace) {
-    const unregistered = [];
-    const types = nodeComponentRegistry.getTypes();
-    for (const type of types) {
-        if (type.startsWith(`${namespace}:`)) {
-            if (nodeComponentRegistry.unregister(type)) {
-                unregistered.push(type);
-            }
-        }
-    }
-    return unregistered;
-}
-/**
- * Check if a namespace is valid.
- * Must be lowercase alphanumeric with optional hyphens.
- *
- * @param namespace - The namespace to validate
- * @returns true if valid
- */
-export function isValidNamespace(namespace) {
-    return /^[a-z][a-z0-9-]*$/.test(namespace);
-}
-/**
- * Get all registered plugins (unique namespaces).
- *
- * @returns Array of namespace strings
- */
-export function getRegisteredPlugins() {
-    const sources = new Set();
-    const registrations = nodeComponentRegistry.getAll();
-    for (const reg of registrations) {
-        if (reg.source && reg.source !== 'flowdrop') {
-            sources.add(reg.source);
-        }
-    }
-    return Array.from(sources);
-}
-/**
- * Get the count of nodes registered by a plugin.
- *
- * @param namespace - The plugin namespace
- * @returns Number of nodes registered by this plugin
- */
-export function getPluginNodeCount(namespace) {
-    return nodeComponentRegistry.getBySource(namespace).length;
-}
-/**
- * Register a single custom node without a full plugin.
- * Useful for project-specific custom nodes.
- *
- * @param type - Type identifier (can be namespaced or plain)
- * @param displayName - Display name for UI
- * @param component - Svelte component
- * @param options - Additional options
- *
- * @example
- * ```typescript
- * import { registerCustomNode } from "@flowdrop/lib";
- * import MyNode from "./MyNode.svelte";
- *
- * registerCustomNode("myproject:special", "Special Node", MyNode, {
- *     icon: "mdi:star",
- *     description: "A special node for my project"
- * });
- * ```
- */
-export function registerCustomNode(type, displayName, component, options = {}) {
-    nodeComponentRegistry.register({
-        type,
-        displayName,
-        component,
-        description: options.description,
-        icon: options.icon,
-        category: options.category ?? 'custom',
-        source: options.source ?? 'custom',
-        statusPosition: options.statusPosition,
-        statusSize: options.statusSize
-    });
-}
-/**
- * Create a plugin builder for a fluent API experience.
- *
- * @param namespace - Plugin namespace
- * @param name - Plugin name
- * @returns Plugin builder with chainable methods
- *
- * @example
- * ```typescript
- * import { createPlugin } from "@flowdrop/lib";
- *
- * createPlugin("awesome", "Awesome Nodes")
- *     .version("1.0.0")
- *     .node("fancy", "Fancy Node", FancyNode)
- *     .node("glow", "Glowing Node", GlowNode, { icon: "mdi:lightbulb" })
- *     .register();
- * ```
- */
-export function createPlugin(namespace, name) {
-    const config = {
-        namespace,
-        name,
-        nodes: []
-    };
-    const builder = {
-        /**
-         * Set plugin version
-         */
-        version(v) {
-            config.version = v;
-            return builder;
-        },
-        /**
-         * Set plugin description
-         */
-        description(desc) {
-            config.description = desc;
-            return builder;
-        },
-        /**
-         * Add a node to the plugin
-         */
-        node(type, displayName, component, options = {}) {
-            config.nodes.push({
-                type,
-                displayName,
-                component,
-                ...options
-            });
-            return builder;
-        },
-        /**
-         * Register the plugin
-         */
-        register() {
-            return registerFlowDropPlugin(config);
-        },
-        /**
-         * Get the config without registering (for testing/inspection)
-         */
-        getConfig() {
-            return { ...config };
-        }
-    };
-    return builder;
-}

package/dist/services/api.d.ts

@@ -1,129 +0,0 @@
-/**
- * Client-side API service for FlowDrop
- * Provides methods to interact with the backend APIs using configurable endpoints
- */
-import type { NodeMetadata, Workflow } from '../types/index.js';
-import type { EndpointConfig } from '../config/endpoints.js';
-/**
- * Set the endpoint configuration at runtime
- */
-export declare function setEndpointConfig(config: EndpointConfig): void;
-/**
- * Get the current endpoint configuration
- */
-export declare function getEndpointConfig(): EndpointConfig | null;
-/**
- * Node API methods
- */
-export declare const nodeApi: {
-    /**
-     * Get all node types with optional filtering
-     */
-    getNodes(options?: {
-        category?: string;
-        search?: string;
-        limit?: number;
-        offset?: number;
-    }): Promise<NodeMetadata[]>;
-    /**
-     * Get a specific node type by ID
-     */
-    getNode(id: string): Promise<NodeMetadata>;
-};
-/**
- * Workflow API methods
- */
-export declare const workflowApi: {
-    /**
-     * Get all workflows with optional filtering
-     */
-    getWorkflows(options?: {
-        search?: string;
-        limit?: number;
-        offset?: number;
-    }): Promise<Workflow[]>;
-    /**
-     * Get a specific workflow by ID
-     */
-    getWorkflow(id: string): Promise<Workflow>;
-    /**
-     * Create a new workflow
-     */
-    createWorkflow(workflow: Omit<Workflow, "id">): Promise<Workflow>;
-    /**
-     * Update an existing workflow
-     */
-    updateWorkflow(id: string, workflow: Partial<Workflow>): Promise<Workflow>;
-    /**
-     * Delete a workflow
-     */
-    deleteWorkflow(id: string): Promise<void>;
-    /**
-     * Save workflow (create or update).
-     *
-     * A workflow is considered existing when it already has an id (any format —
-     * integer, UUID, slug). Only a missing/empty id means "truly new".
-     *
-     * Note: globalSave.ts bypasses this method and calls createWorkflow /
-     * updateWorkflow directly so it can capture the new/existing decision before
-     * the uuidv4() fallback. This method is kept for external callers.
-     */
-    saveWorkflow(workflow: Workflow): Promise<Workflow>;
-};
-/**
- * Export the API service
- */
-export declare const api: {
-    nodes: {
-        /**
-         * Get all node types with optional filtering
-         */
-        getNodes(options?: {
-            category?: string;
-            search?: string;
-            limit?: number;
-            offset?: number;
-        }): Promise<NodeMetadata[]>;
-        /**
-         * Get a specific node type by ID
-         */
-        getNode(id: string): Promise<NodeMetadata>;
-    };
-    workflows: {
-        /**
-         * Get all workflows with optional filtering
-         */
-        getWorkflows(options?: {
-            search?: string;
-            limit?: number;
-            offset?: number;
-        }): Promise<Workflow[]>;
-        /**
-         * Get a specific workflow by ID
-         */
-        getWorkflow(id: string): Promise<Workflow>;
-        /**
-         * Create a new workflow
-         */
-        createWorkflow(workflow: Omit<Workflow, "id">): Promise<Workflow>;
-        /**
-         * Update an existing workflow
-         */
-        updateWorkflow(id: string, workflow: Partial<Workflow>): Promise<Workflow>;
-        /**
-         * Delete a workflow
-         */
-        deleteWorkflow(id: string): Promise<void>;
-        /**
-         * Save workflow (create or update).
-         *
-         * A workflow is considered existing when it already has an id (any format —
-         * integer, UUID, slug). Only a missing/empty id means "truly new".
-         *
-         * Note: globalSave.ts bypasses this method and calls createWorkflow /
-         * updateWorkflow directly so it can capture the new/existing decision before
-         * the uuidv4() fallback. This method is kept for external callers.
-         */
-        saveWorkflow(workflow: Workflow): Promise<Workflow>;
-    };
-};

package/dist/services/api.js

@@ -1,217 +0,0 @@
-/**
- * Client-side API service for FlowDrop
- * Provides methods to interact with the backend APIs using configurable endpoints
- */
-import { buildEndpointUrl, getEndpointMethod, getEndpointHeaders } from '../config/endpoints.js';
-let endpointConfig = null;
-/**
- * Set the endpoint configuration at runtime
- */
-export function setEndpointConfig(config) {
-    endpointConfig = config;
-}
-/**
- * Get the current endpoint configuration
- */
-export function getEndpointConfig() {
-    return endpointConfig;
-}
-/**
- * Generic API request helper with endpoint configuration
- */
-async function apiRequest(endpointKey, endpointPath, params, options = {}) {
-    if (!endpointConfig) {
-        throw new Error('Endpoint configuration not set. Call setEndpointConfig() first.');
-    }
-    const url = buildEndpointUrl(endpointConfig, endpointPath, params);
-    const method = getEndpointMethod(endpointConfig, endpointKey);
-    const headers = getEndpointHeaders(endpointConfig, endpointKey);
-    const response = await fetch(url, {
-        method,
-        headers,
-        ...options
-    });
-    // Check if response is JSON
-    const contentType = response.headers.get('content-type');
-    const isJson = contentType?.includes('application/json');
-    if (!response.ok) {
-        // Try to get error details
-        let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
-        if (isJson) {
-            try {
-                const data = await response.json();
-                errorMessage = data.error || data.message || errorMessage;
-            }
-            catch {
-                // Failed to parse JSON, use default error message
-            }
-        }
-        else {
-            // Response is not JSON (probably HTML error page)
-            try {
-                const text = await response.text();
-                // Extract first 200 characters for debugging
-                const preview = text.substring(0, 200).trim();
-                errorMessage = `${errorMessage}. Server returned: ${preview}...`;
-            }
-            catch {
-                // Failed to read response text
-            }
-        }
-        throw new Error(errorMessage);
-    }
-    // Parse successful response
-    const data = await response.json();
-    return data;
-}
-/**
- * Node API methods
- */
-export const nodeApi = {
-    /**
-     * Get all node types with optional filtering
-     */
-    async getNodes(options) {
-        if (!endpointConfig) {
-            throw new Error('Endpoint configuration not set');
-        }
-        const params = new URLSearchParams();
-        if (options?.category)
-            params.append('category', options.category);
-        if (options?.search)
-            params.append('search', options.search);
-        if (options?.limit)
-            params.append('limit', options.limit.toString());
-        if (options?.offset)
-            params.append('offset', options.offset.toString());
-        const response = await apiRequest('nodes.list', endpointConfig.endpoints.nodes.list + '?' + params.toString());
-        return response.data || [];
-    },
-    /**
-     * Get a specific node type by ID
-     */
-    async getNode(id) {
-        if (!endpointConfig) {
-            throw new Error('Endpoint configuration not set');
-        }
-        const response = await apiRequest('nodes.get', endpointConfig.endpoints.nodes.get, { id });
-        if (!response.data) {
-            throw new Error('Node not found');
-        }
-        return response.data;
-    }
-};
-/**
- * Workflow API methods
- */
-export const workflowApi = {
-    /**
-     * Get all workflows with optional filtering
-     */
-    async getWorkflows(options) {
-        if (!endpointConfig) {
-            throw new Error('Endpoint configuration not set');
-        }
-        const params = new URLSearchParams();
-        if (options?.search)
-            params.append('search', options.search);
-        if (options?.limit)
-            params.append('limit', options.limit.toString());
-        if (options?.offset)
-            params.append('offset', options.offset.toString());
-        const response = await apiRequest('workflows.list', endpointConfig.endpoints.workflows.list + '?' + params.toString());
-        return response.data || [];
-    },
-    /**
-     * Get a specific workflow by ID
-     */
-    async getWorkflow(id) {
-        if (!endpointConfig) {
-            throw new Error('Endpoint configuration not set');
-        }
-        const response = await apiRequest('workflows.get', endpointConfig.endpoints.workflows.get, { id });
-        if (!response.data) {
-            throw new Error('Workflow not found');
-        }
-        return response.data;
-    },
-    /**
-     * Create a new workflow
-     */
-    async createWorkflow(workflow) {
-        if (!endpointConfig) {
-            throw new Error('Endpoint configuration not set');
-        }
-        // Apply the consumer-provided payload transform (e.g. Drupal's label mapping).
-        // The default is the identity function — no CMS-specific logic in the core library.
-        const transform = endpointConfig.transformWorkflowPayload ?? ((w) => w);
-        const body = transform(workflow);
-        const response = await apiRequest('workflows.create', endpointConfig.endpoints.workflows.create, undefined, {
-            method: 'POST',
-            body: JSON.stringify(body)
-        });
-        if (!response.data) {
-            throw new Error('Failed to create workflow');
-        }
-        return response.data;
-    },
-    /**
-     * Update an existing workflow
-     */
-    async updateWorkflow(id, workflow) {
-        if (!endpointConfig) {
-            throw new Error('Endpoint configuration not set');
-        }
-        // Apply the consumer-provided payload transform (e.g. Drupal's label mapping).
-        // The default is the identity function — no CMS-specific logic in the core library.
-        const transform = endpointConfig.transformWorkflowPayload ?? ((w) => w);
-        const body = transform(workflow);
-        const response = await apiRequest('workflows.update', endpointConfig.endpoints.workflows.update, { id }, {
-            method: 'PUT',
-            body: JSON.stringify(body)
-        });
-        if (!response.data) {
-            throw new Error('Failed to update workflow');
-        }
-        return response.data;
-    },
-    /**
-     * Delete a workflow
-     */
-    async deleteWorkflow(id) {
-        if (!endpointConfig) {
-            throw new Error('Endpoint configuration not set');
-        }
-        await apiRequest('workflows.delete', endpointConfig.endpoints.workflows.delete, { id }, { method: 'DELETE' });
-    },
-    /**
-     * Save workflow (create or update).
-     *
-     * A workflow is considered existing when it already has an id (any format —
-     * integer, UUID, slug). Only a missing/empty id means "truly new".
-     *
-     * Note: globalSave.ts bypasses this method and calls createWorkflow /
-     * updateWorkflow directly so it can capture the new/existing decision before
-     * the uuidv4() fallback. This method is kept for external callers.
-     */
-    async saveWorkflow(workflow) {
-        const isExistingWorkflow = !!(workflow.id && workflow.id.length > 0);
-        if (isExistingWorkflow) {
-            // Update existing workflow
-            return this.updateWorkflow(workflow.id, workflow);
-        }
-        else {
-            // Create new workflow
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const { id, ...workflowData } = workflow;
-            return this.createWorkflow(workflowData);
-        }
-    }
-};
-/**
- * Export the API service
- */
-export const api = {
-    nodes: nodeApi,
-    workflows: workflowApi
-};