@flowdrop/flowdrop 1.15.0 → 2.0.0-beta.2

package/dist/stores/instanceContainer.svelte.js

@@ -0,0 +1,114 @@
+/**
+ * FlowDrop Instance Container
+ *
+ * Holds all per-instance state for one FlowDrop editor: workflow state,
+ * undo/redo history, playground sessions, interrupts, port coordinates,
+ * categories, and pipeline panel state. Creating one container per mount is
+ * what allows multiple FlowDrop editors to coexist on a single page.
+ *
+ * The container is provided to the component tree via Svelte context (see
+ * `getInstance.svelte.ts`). A lazily-created, browser-only default instance
+ * backs the legacy module-level store APIs so existing single-instance
+ * consumers keep working unchanged.
+ *
+ * @module stores/instanceContainer
+ */
+import { HistoryService, historyService } from '../services/historyService.js';
+import { WorkflowStore } from './workflowStore.svelte.js';
+import { HistoryStore } from './historyStore.svelte.js';
+import { PlaygroundStore } from './playgroundStore.svelte.js';
+import { InterruptStore } from './interruptStore.svelte.js';
+import { CategoriesStore } from './categoriesStore.svelte.js';
+import { PortCoordinateStore } from './portCoordinateStore.svelte.js';
+import { PipelinePanelStore } from './pipelinePanelStore.svelte.js';
+import { ApiContext } from './apiContext.js';
+import { PortCompatibilityChecker } from '../utils/connections.js';
+import { DEFAULT_PORT_CONFIG } from '../config/defaultPortConfig.js';
+import { NodeComponentRegistry } from '../registry/nodeComponentRegistry.js';
+import { FieldComponentRegistry } from '../form/fieldRegistry.js';
+import { WorkflowFormatRegistry } from '../registry/workflowFormatRegistry.js';
+import { BUILTIN_NODE_COMPONENTS } from '../registry/builtinNodes.js';
+import { getBuiltinFormatAdapters } from '../registry/builtinFormats.js';
+/** Storage key prefix shared by the default instance and legacy consumers. */
+export const DEFAULT_DRAFT_PREFIX = 'flowdrop:draft';
+// Feeds auto-generated ids only (`fd-1`, `fd-2`, …) — cosmetic monotonicity.
+// Incrementing across SSR requests is harmless; no state hangs off the value.
+let instanceCounter = 0;
+/**
+ * Create a fully wired FlowDrop instance.
+ *
+ * Creation order matters: history first, then stores that depend on it
+ * (constructor injection — no module-singleton imports).
+ */
+export function createFlowDropInstance(options = {}) {
+    const isDefault = options.isDefault ?? false;
+    const id = options.id ?? (isDefault ? 'default' : `fd-${++instanceCounter}`);
+    // Every instance gets an id-scoped prefix — the default instance's 1.x bare
+    // keys are migrated on first read (see migrateLegacyDraftKey / PipelinePanelStore.init).
+    const storagePrefix = `${DEFAULT_DRAFT_PREFIX}:${id}`;
+    // The default instance reuses the exported singleton (public API via
+    // `@flowdrop/flowdrop/editor`) so external `historyService.undo()` etc.
+    // keep operating on the default editor's history stack.
+    const history = isDefault ? historyService : new HistoryService();
+    const workflow = new WorkflowStore(history);
+    const historyBindings = new HistoryStore(history);
+    // Default wiring: undo/redo restores into this instance's workflow store.
+    // WorkflowEditor overrides this with a richer callback while mounted.
+    historyBindings.setOnRestoreCallback((restored) => workflow.restoreFromHistory(restored));
+    const playground = new PlaygroundStore();
+    const cleanups = [
+        () => historyBindings.cleanup(),
+        () => historyBindings.setOnRestoreCallback(null),
+        () => workflow.setOnDirtyStateChange(null),
+        () => workflow.setOnWorkflowChange(null),
+        () => playground.dispose()
+    ];
+    return {
+        id,
+        storagePrefix,
+        isDefault,
+        history,
+        workflow,
+        historyBindings,
+        playground,
+        interrupts: new InterruptStore(),
+        api: new ApiContext(),
+        nodes: new NodeComponentRegistry({
+            registrations: BUILTIN_NODE_COMPONENTS,
+            defaultType: 'workflowNode'
+        }),
+        fields: new FieldComponentRegistry(),
+        formats: new WorkflowFormatRegistry(getBuiltinFormatAdapters()),
+        categories: new CategoriesStore(),
+        portCoordinates: new PortCoordinateStore(),
+        portCompatibility: new PortCompatibilityChecker(DEFAULT_PORT_CONFIG),
+        // The default instance keeps the legacy bare localStorage key.
+        pipelinePanel: new PipelinePanelStore(id),
+        destroy() {
+            while (cleanups.length > 0) {
+                cleanups.pop()?.();
+            }
+        }
+    };
+}
+// =========================================================================
+// Default instance (backward compatibility)
+// =========================================================================
+let defaultInstance = null;
+/**
+ * Get the page-default FlowDrop instance, creating it on first access.
+ *
+ * **Browser-only.** Reactive per-user state must never live at module scope
+ * on the server — a module-level default would leak between SvelteKit
+ * requests. Server renders must provide an instance via context instead
+ * (`<App>` and `<WorkflowEditor>` do this automatically).
+ */
+export function getDefaultInstance() {
+    if (typeof window === 'undefined') {
+        throw new Error('[flowdrop] The default FlowDrop instance is browser-only to prevent ' +
+            'cross-request state leakage during SSR. Render inside <App> or ' +
+            '<WorkflowEditor> (which provide an instance via context), or pass ' +
+            'an explicit instance.');
+    }
+    return (defaultInstance ??= createFlowDropInstance({ isDefault: true }));
+}

package/dist/stores/interruptStore.svelte.d.ts

@@ -4,6 +4,9 @@
  * Rune-based reactive state for managing interrupt state using a lightweight state machine.
  * Ensures valid state transitions and prevents deadlocks.
  *
+ * The reactive state lives in the {@link InterruptStore} class — one per
+ * FlowDrop instance, resolved in components via `getInstance().interrupts`.
+ *
  * @module stores/interruptStore
  */
 import { SvelteMap } from 'svelte/reactivity';
@@ -17,46 +20,73 @@ export interface InterruptWithState extends Interrupt {
     machineState: InterruptState;
 }
 /**
- * Get the reactive interrupts map.
- * Use this in components within $derived() for reactivity.
- */
-export declare function getInterruptsMap(): SvelteMap<string, InterruptWithState>;
-/**
- * Get pending interrupt IDs (interrupts not in a terminal state)
- */
-export declare function getPendingInterruptIds(): string[];
-/**
- * Get pending interrupts array (interrupts not in a terminal state)
- */
-export declare function getPendingInterrupts(): InterruptWithState[];
-/**
- * Get count of pending interrupts
- */
-export declare function getPendingInterruptCount(): number;
-/**
- * Get resolved interrupts array
+ * Interrupt store actions for modifying state.
  */
-export declare function getResolvedInterrupts(): InterruptWithState[];
-/**
- * Check if any interrupt is currently submitting
- */
-export declare function getIsAnySubmitting(): boolean;
+export interface InterruptStoreActions {
+    addInterrupt: (interrupt: Interrupt) => void;
+    addInterrupts: (interruptList: Interrupt[]) => void;
+    startSubmit: (interruptId: string, value: unknown) => TransitionResult;
+    startCancel: (interruptId: string) => TransitionResult;
+    submitSuccess: (interruptId: string) => TransitionResult;
+    submitFailure: (interruptId: string, error: string) => TransitionResult;
+    retry: (interruptId: string) => TransitionResult;
+    resetInterrupt: (interruptId: string) => TransitionResult;
+    resolveInterrupt: (interruptId: string, value: unknown) => void;
+    cancelInterrupt: (interruptId: string) => void;
+    removeInterrupt: (interruptId: string) => void;
+    clearSessionInterrupts: (sessionId: string) => void;
+    clearInterrupts: () => void;
+    reset: () => void;
+}
 /**
- * Interrupt store actions for modifying state
+ * Per-instance interrupt state, managed via a lightweight state machine.
+ *
+ * Reads go through getter methods backed by a {@link SvelteMap}, so reading
+ * them inside a component template or `$derived` tracks reactively, exactly
+ * like the legacy module-level functions did.
  */
-export declare const interruptActions: {
+export declare class InterruptStore {
+    #private;
+    /** Bound mutation facade — see {@link InterruptStoreActions}. */
+    readonly actions: InterruptStoreActions;
+    constructor();
+    /**
+     * Get the reactive interrupts map.
+     * Use this in components within $derived() for reactivity.
+     */
+    getMap(): SvelteMap<string, InterruptWithState>;
+    /**
+     * Get pending interrupt IDs (interrupts not in a terminal state)
+     */
+    getPendingIds(): string[];
+    /**
+     * Get pending interrupts array (interrupts not in a terminal state)
+     */
+    getPending(): InterruptWithState[];
+    /**
+     * Get count of pending interrupts
+     */
+    getPendingCount(): number;
+    /**
+     * Get resolved interrupts array
+     */
+    getResolved(): InterruptWithState[];
+    /**
+     * Check if any interrupt is currently submitting
+     */
+    getIsAnySubmitting(): boolean;
     /**
      * Add or update an interrupt in the store
      *
      * @param interrupt - The interrupt to add or update
      */
-    addInterrupt: (interrupt: Interrupt) => void;
+    addInterrupt(interrupt: Interrupt): void;
     /**
      * Add multiple interrupts to the store
      *
      * @param interruptList - Array of interrupts to add
      */
-    addInterrupts: (interruptList: Interrupt[]) => void;
+    addInterrupts(interruptList: Interrupt[]): void;
     /**
      * Start submitting an interrupt (user clicked submit)
      *
@@ -64,21 +94,21 @@ export declare const interruptActions: {
      * @param value - The value being submitted
      * @returns Transition result
      */
-    startSubmit: (interruptId: string, value: unknown) => TransitionResult;
+    startSubmit(interruptId: string, value: unknown): TransitionResult;
     /**
      * Start cancelling an interrupt (user clicked cancel)
      *
      * @param interruptId - The interrupt ID
      * @returns Transition result
      */
-    startCancel: (interruptId: string) => TransitionResult;
+    startCancel(interruptId: string): TransitionResult;
     /**
      * Mark submission as successful
      *
      * @param interruptId - The interrupt ID
      * @returns Transition result
      */
-    submitSuccess: (interruptId: string) => TransitionResult;
+    submitSuccess(interruptId: string): TransitionResult;
     /**
      * Mark submission as failed
      *
@@ -86,94 +116,94 @@ export declare const interruptActions: {
      * @param error - Error message
      * @returns Transition result
      */
-    submitFailure: (interruptId: string, error: string) => TransitionResult;
+    submitFailure(interruptId: string, error: string): TransitionResult;
     /**
      * Retry a failed submission
      *
      * @param interruptId - The interrupt ID
      * @returns Transition result
      */
-    retry: (interruptId: string) => TransitionResult;
+    retry(interruptId: string): TransitionResult;
     /**
      * Reset an interrupt to idle state
      *
      * @param interruptId - The interrupt ID
      * @returns Transition result
      */
-    resetInterrupt: (interruptId: string) => TransitionResult;
+    resetInterrupt(interruptId: string): TransitionResult;
     /**
      * Mark an interrupt as resolved with the user's response
      *
      * @param interruptId - The interrupt ID
      * @param value - The resolved value
      */
-    resolveInterrupt: (interruptId: string, value: unknown) => void;
+    resolveInterrupt(interruptId: string, value: unknown): void;
     /**
      * Mark an interrupt as cancelled
      *
      * @param interruptId - The interrupt ID
      */
-    cancelInterrupt: (interruptId: string) => void;
+    cancelInterrupt(interruptId: string): void;
     /**
      * Remove an interrupt from the store
      *
      * @param interruptId - The interrupt ID to remove
      */
-    removeInterrupt: (interruptId: string) => void;
+    removeInterrupt(interruptId: string): void;
     /**
      * Clear all interrupts for a specific session
      *
      * @param sessionId - The session ID to clear interrupts for
      */
-    clearSessionInterrupts: (sessionId: string) => void;
+    clearSessionInterrupts(sessionId: string): void;
     /**
      * Alias for clearSessionInterrupts
      */
-    clearInterrupts: () => void;
+    clearInterrupts(): void;
     /**
      * Reset all interrupt state
      */
-    reset: () => void;
-};
-/**
- * Get an interrupt by ID
- *
- * @param interruptId - The interrupt ID
- * @returns The interrupt or undefined
- */
-export declare function getInterrupt(interruptId: string): InterruptWithState | undefined;
-/**
- * Check if an interrupt is pending (not resolved or cancelled)
- *
- * @param interruptId - The interrupt ID
- * @returns True if the interrupt exists and is pending
- */
-export declare function isInterruptPending(interruptId: string): boolean;
-/**
- * Check if an interrupt is currently submitting
- *
- * @param interruptId - The interrupt ID
- * @returns True if the interrupt is being submitted
- */
-export declare function isInterruptSubmitting(interruptId: string): boolean;
-/**
- * Get the error for an interrupt
- *
- * @param interruptId - The interrupt ID
- * @returns The error message or undefined
- */
-export declare function getInterruptError(interruptId: string): string | undefined;
-/**
- * Get an interrupt by its associated message ID
- *
- * @param messageId - The message ID
- * @returns The interrupt or undefined
- */
-export declare function getInterruptByMessageId(messageId: string): InterruptWithState | undefined;
-/**
- * Check if an interrupt has an error
- *
- * @param interruptId - The interrupt ID
- * @returns True if the interrupt has an error
- */
-export declare function interruptHasError(interruptId: string): boolean;
+    reset(): void;
+    /**
+     * Get an interrupt by ID
+     *
+     * @param interruptId - The interrupt ID
+     * @returns The interrupt or undefined
+     */
+    getInterrupt(interruptId: string): InterruptWithState | undefined;
+    /**
+     * Check if an interrupt is pending (not resolved or cancelled)
+     *
+     * @param interruptId - The interrupt ID
+     * @returns True if the interrupt exists and is pending
+     */
+    isPending(interruptId: string): boolean;
+    /**
+     * Check if an interrupt is currently submitting
+     *
+     * @param interruptId - The interrupt ID
+     * @returns True if the interrupt is being submitted
+     */
+    isSubmitting(interruptId: string): boolean;
+    /**
+     * Get the error for an interrupt
+     *
+     * @param interruptId - The interrupt ID
+     * @returns The error message or undefined
+     */
+    getError(interruptId: string): string | undefined;
+    /**
+     * Get an interrupt by its associated message ID
+     *
+     * @param messageId - The message ID
+     * @returns The interrupt or undefined
+     */
+    getByMessageId(messageId: string): InterruptWithState | undefined;
+    /**
+     * Check if an interrupt has an error
+     *
+     * @param interruptId - The interrupt ID
+     * @returns True if the interrupt has an error
+     */
+    hasError(interruptId: string): boolean;
+}