@flowdrop/flowdrop 1.15.0 → 2.0.0-beta.1

package/dist/utils/nodeTypes.js

@@ -9,7 +9,6 @@
  *
  * Works with both built-in types and custom registered types.
  */
-import { nodeComponentRegistry } from '../registry/nodeComponentRegistry.js';
 import { resolveBuiltinAlias, isBuiltinType } from '../registry/builtinNodes.js';
 /**
  * Display names for built-in node types.
@@ -28,14 +27,15 @@ const TYPE_DISPLAY_NAMES = {
  * Gets the SvelteFlow component name for a given NodeType.
  * Uses the node component registry to resolve types.
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param nodeType - The node type identifier
  * @returns The component name to use
  */
-export function getComponentNameForNodeType(nodeType) {
+export function getComponentNameForNodeType(registry, nodeType) {
     // Resolve aliases first (e.g., "default" -> "workflowNode")
     const resolvedType = resolveBuiltinAlias(nodeType);
     // Check if it's registered in the registry
-    if (nodeComponentRegistry.has(resolvedType)) {
+    if (registry.has(resolvedType)) {
         return resolvedType;
     }
     // Unknown type - return workflowNode as default
@@ -77,11 +77,12 @@ export function getPrimaryNodeType(metadata) {
  * 3. First supportedType
  * 4. "default"
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param metadata - The node metadata
  * @param configNodeType - Optional type from user config
  * @returns The resolved node type
  */
-export function resolveNodeType(metadata, configNodeType) {
+export function resolveNodeType(registry, metadata, configNodeType) {
     const availableTypes = getAvailableNodeTypes(metadata);
     // Check if configNodeType is valid for this metadata
     if (configNodeType) {
@@ -93,7 +94,7 @@ export function resolveNodeType(metadata, configNodeType) {
             return configNodeType;
         }
         // Check if it's a registered custom type
-        if (nodeComponentRegistry.has(configNodeType) || nodeComponentRegistry.has(resolvedConfig)) {
+        if (registry.has(configNodeType) || registry.has(resolvedConfig)) {
             return configNodeType;
         }
     }
@@ -104,22 +105,24 @@ export function resolveNodeType(metadata, configNodeType) {
  * Gets the SvelteFlow component name for resolved node type.
  * This is the main function used by UniversalNode to determine which component to render.
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @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);
+export function resolveComponentName(registry, metadata, configNodeType) {
+    const nodeType = resolveNodeType(registry, metadata, configNodeType);
+    return getComponentNameForNodeType(registry, nodeType);
 }
 /**
  * Validates if a node type is supported by the given metadata.
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param metadata - The node metadata
  * @param nodeType - The type to check
  * @returns true if the type is supported
  */
-export function isNodeTypeSupported(metadata, nodeType) {
+export function isNodeTypeSupported(registry, metadata, nodeType) {
     const availableTypes = getAvailableNodeTypes(metadata);
     // Check direct match
     if (availableTypes.includes(nodeType)) {
@@ -131,7 +134,7 @@ export function isNodeTypeSupported(metadata, nodeType) {
         return true;
     }
     // Check if it's a registered custom type that's in the available list
-    if (nodeComponentRegistry.has(nodeType)) {
+    if (registry.has(nodeType)) {
         return availableTypes.some((t) => t === nodeType || resolveBuiltinAlias(t) === nodeType);
     }
     return false;
@@ -144,18 +147,19 @@ export function isNodeTypeSupported(metadata, nodeType) {
  * - Types specified in metadata.supportedTypes
  * - Registered custom types (optionally filtered)
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param metadata - The node metadata
  * @param includeCustomTypes - Whether to include registered custom types
  * @returns Array of oneOf items with const (type value) and title (display name)
  */
-export function getNodeTypeOneOfOptions(metadata, includeCustomTypes = false) {
+export function getNodeTypeOneOfOptions(registry, metadata, includeCustomTypes = false) {
     const availableTypes = getAvailableNodeTypes(metadata);
     const options = [];
     const includedTypes = new Set();
     for (const type of availableTypes) {
         includedTypes.add(type);
         // Get display name from registry or fallback to built-in names
-        const registration = nodeComponentRegistry.get(type);
+        const registration = registry.get(type);
         let title;
         if (registration) {
             title = registration.displayName;
@@ -171,7 +175,7 @@ export function getNodeTypeOneOfOptions(metadata, includeCustomTypes = false) {
     }
     // Optionally include all registered custom types
     if (includeCustomTypes) {
-        const registrations = nodeComponentRegistry.filter({
+        const registrations = registry.filter({
             predicate: (reg) => !isBuiltinType(reg.type) && !includedTypes.has(reg.type)
         });
         for (const reg of registrations) {
@@ -187,12 +191,13 @@ export function getNodeTypeOneOfOptions(metadata, includeCustomTypes = false) {
  * Uses JSON Schema `oneOf` pattern with `const`/`title` for labeled options,
  * which is the standard approach supported by form components.
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param metadata - The node metadata
  * @param defaultType - Optional default type override
  * @returns Config schema property object with oneOf for labeled options
  */
-export function createNodeTypeConfigProperty(metadata, defaultType) {
-    const oneOf = getNodeTypeOneOfOptions(metadata);
+export function createNodeTypeConfigProperty(registry, metadata, defaultType) {
+    const oneOf = getNodeTypeOneOfOptions(registry, metadata);
     const primaryType = defaultType ?? getPrimaryNodeType(metadata);
     return {
         type: 'string',
@@ -205,19 +210,21 @@ export function createNodeTypeConfigProperty(metadata, defaultType) {
 /**
  * Check if a type string represents a valid registered or built-in type.
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @param type - The type to check
  * @returns true if the type is valid
  */
-export function isValidNodeType(type) {
-    return isBuiltinType(type) || nodeComponentRegistry.has(type);
+export function isValidNodeType(registry, type) {
+    return isBuiltinType(type) || registry.has(type);
 }
 /**
  * Get all available node types (built-in + registered).
  *
+ * @param registry - The instance's node component registry (e.g. `fd.nodes`)
  * @returns Array of all valid node type identifiers
  */
-export function getAllNodeTypes() {
-    return nodeComponentRegistry.getTypes();
+export function getAllNodeTypes(registry) {
+    return registry.getTypes();
 }
 /**
  * Format a type name for display when no display name is registered.

package/dist/utils/performanceUtils.js

@@ -51,6 +51,9 @@ export function areEdgeArraysEqual(edges1, edges2) {
  * Throttle function execution to reduce frequency
  * Uses requestAnimationFrame for smooth UI updates
  */
+// `any[]` in a generic constraint is the variance-correct idiom (it's how the TS
+// stdlib types Parameters<T>); `unknown[]` would reject every concrete callback.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function throttle(func, wait) {
     let timeout = null;
     let lastRan = 0;
@@ -75,6 +78,8 @@ export function throttle(func, wait) {
  * Debounce function execution to reduce frequency
  * Waits for a pause in calls before executing
  */
+// `any[]` constraint: see throttle() above.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function debounce(func, wait) {
     let timeout = null;
     return function (...args) {
@@ -90,6 +95,8 @@ export function debounce(func, wait) {
  * RequestAnimationFrame-based throttle for smooth animations
  * Better for visual updates like node dragging
  */
+// `any[]` constraint: see throttle() above.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function rafThrottle(func) {
     let rafId = null;
     let lastArgs = null;

package/package.json

@@ -3,7 +3,7 @@
   "description": "A drop-in visual workflow editor for any web application. You own the backend. You own the data. You own the orchestration.",
   "license": "MIT",
   "private": false,
-  "version": "1.15.0",
+  "version": "2.0.0-beta.1",
   "author": "Shibin Das (D34dMan)",
   "bugs": {
     "url": "https://github.com/flowdrop-io/flowdrop/issues"
@@ -47,12 +47,12 @@
     "dist",
     "!dist/**/*.test.*",
     "!dist/**/*.spec.*",
-    "!dist/**/*.map"
+    "!dist/**/*.map",
+    "CHANGELOG.md",
+    "MIGRATION-2.0.md"
   ],
   "sideEffects": [
-    "**/*.css",
-    "./dist/styles/base.css",
-    "./dist/editor/index.js"
+    "**/*.css"
   ],
   "svelte": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -269,6 +269,7 @@
   "dependencies": {
     "diff": "^8.0.3",
     "dompurify": "^3.3.1",
+    "esm-env": "^1.2.2",
     "marked": "^16.1.1",
     "svelte-5-french-toast": "^2.0.6",
     "uuid": "^11.1.0"

package/dist/messages/deprecation.d.ts

@@ -1,20 +0,0 @@
-/**
- * One-shot deprecation warning helper for the messages migration.
- *
- * Components that previously accepted per-string label props (e.g.
- * `saveLabel`, `cancelLabel`, `placeholder`, `addLabel`) keep accepting them
- * during the v1.x deprecation window. When a consumer passes one explicitly
- * we emit a single console.warn per (component, prop) pair so the noise is
- * bounded even if the prop is rebound on every render.
- *
- * Production builds skip the warning entirely.
- *
- * Removed in v2.0 along with the props themselves.
- */
-export declare function warnDeprecatedProp(component: string, prop: string, replacement: string): void;
-/**
- * Test-only: clear the warned-once cache so subsequent renders re-emit the
- * warning. Storybook stories and Vitest specs that share a module instance
- * need this to assert the warning fires per case.
- */
-export declare function __resetDeprecationWarningsForTests(): void;

package/dist/messages/deprecation.js

@@ -1,33 +0,0 @@
-/**
- * One-shot deprecation warning helper for the messages migration.
- *
- * Components that previously accepted per-string label props (e.g.
- * `saveLabel`, `cancelLabel`, `placeholder`, `addLabel`) keep accepting them
- * during the v1.x deprecation window. When a consumer passes one explicitly
- * we emit a single console.warn per (component, prop) pair so the noise is
- * bounded even if the prop is rebound on every render.
- *
- * Production builds skip the warning entirely.
- *
- * Removed in v2.0 along with the props themselves.
- */
-const warned = new Set();
-export function warnDeprecatedProp(component, prop, replacement) {
-    if (import.meta.env.PROD)
-        return;
-    const key = `${component}.${prop}`;
-    if (warned.has(key))
-        return;
-    warned.add(key);
-    // eslint-disable-next-line no-console
-    console.warn(`[flowdrop] <${component}> prop \`${prop}\` is deprecated and will be removed in v2.0. ` +
-        `Use \`messages\` on <FlowDrop> instead: ${replacement}`);
-}
-/**
- * Test-only: clear the warned-once cache so subsequent renders re-emit the
- * warning. Storybook stories and Vitest specs that share a module instance
- * need this to assert the warning fires per case.
- */
-export function __resetDeprecationWarningsForTests() {
-    warned.clear();
-}

package/dist/registry/plugin.d.ts

@@ -1,215 +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 { type NodeComponentProps, type NodeComponentCategory, type StatusPosition, type StatusSize } from './nodeComponentRegistry.js';
-import type { Component } from 'svelte';
-/**
- * Plugin configuration for external libraries.
- * Use this to register multiple node types from a library.
- */
-export interface FlowDropPluginConfig {
-    /**
-     * Unique namespace for this plugin.
-     * Used to prefix all node types (e.g., "mylib" -> "mylib:nodename").
-     * Should be lowercase, alphanumeric with optional hyphens.
-     */
-    namespace: string;
-    /** Display name for the plugin (for UI/debugging purposes) */
-    name: string;
-    /** Plugin version (optional, for debugging) */
-    version?: string;
-    /** Description of what this plugin provides */
-    description?: string;
-    /** Node components to register */
-    nodes: PluginNodeDefinition[];
-}
-/**
- * Simplified node definition for plugins.
- * Provides a cleaner API than full NodeComponentRegistration.
- */
-export interface PluginNodeDefinition {
-    /**
-     * Type identifier for this node.
-     * Will be prefixed with the plugin namespace (e.g., "fancy" -> "mylib:fancy").
-     */
-    type: string;
-    /** Display name shown in UI */
-    displayName: string;
-    /** Description of what this node does */
-    description?: string;
-    /** The Svelte component to render */
-    component: Component<NodeComponentProps>;
-    /** Icon in iconify format (e.g., "mdi:star") */
-    icon?: string;
-    /** Category for organizing in UI */
-    category?: NodeComponentCategory;
-    /** Status overlay position */
-    statusPosition?: StatusPosition;
-    /** Status overlay size */
-    statusSize?: StatusSize;
-}
-/**
- * Result of plugin registration.
- * Contains information about what was registered and any errors.
- */
-export interface PluginRegistrationResult {
-    /** Whether all nodes were registered successfully */
-    success: boolean;
-    /** The plugin namespace */
-    namespace: string;
-    /** Array of successfully registered type identifiers (namespaced) */
-    registeredTypes: string[];
-    /** Array of error messages for failed registrations */
-    errors: string[];
-}
-/**
- * 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 declare function registerFlowDropPlugin(config: FlowDropPluginConfig): PluginRegistrationResult;
-/**
- * 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 declare function unregisterFlowDropPlugin(namespace: string): string[];
-/**
- * Check if a namespace is valid.
- * Must be lowercase alphanumeric with optional hyphens.
- *
- * @param namespace - The namespace to validate
- * @returns true if valid
- */
-export declare function isValidNamespace(namespace: string): boolean;
-/**
- * Get all registered plugins (unique namespaces).
- *
- * @returns Array of namespace strings
- */
-export declare function getRegisteredPlugins(): string[];
-/**
- * Get the count of nodes registered by a plugin.
- *
- * @param namespace - The plugin namespace
- * @returns Number of nodes registered by this plugin
- */
-export declare function getPluginNodeCount(namespace: string): number;
-/**
- * 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 declare function registerCustomNode(type: string, displayName: string, component: Component<NodeComponentProps>, options?: {
-    description?: string;
-    icon?: string;
-    category?: NodeComponentCategory;
-    source?: string;
-    statusPosition?: StatusPosition;
-    statusSize?: StatusSize;
-}): void;
-/**
- * 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 declare function createPlugin(namespace: string, name: string): {
-    /**
-     * Set plugin version
-     */
-    version(v: string): /*elided*/ any;
-    /**
-     * Set plugin description
-     */
-    description(desc: string): /*elided*/ any;
-    /**
-     * Add a node to the plugin
-     */
-    node(type: string, displayName: string, component: Component<NodeComponentProps>, options?: Partial<Omit<PluginNodeDefinition, "type" | "displayName" | "component">>): /*elided*/ any;
-    /**
-     * Register the plugin
-     */
-    register(): PluginRegistrationResult;
-    /**
-     * Get the config without registering (for testing/inspection)
-     */
-    getConfig(): FlowDropPluginConfig;
-};