@flowdrop/flowdrop 1.15.0 → 2.0.0-beta.1

package/dist/stores/interruptStore.svelte.js

@@ -4,171 +4,198 @@
  * 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';
 import { initialState, transition, isTerminalState, isSubmitting as checkIsSubmitting, hasError as checkHasError, getErrorMessage, getResolvedValue, toLegacyStatus } from '../types/interruptState.js';
 import { logger } from '../utils/logger.js';
 // =========================================================================
-// Core Reactive State
-// =========================================================================
-/**
- * Reactive map of all interrupts by ID.
- * Uses SvelteMap for deep reactivity with Svelte 5 runes.
- * Key: interrupt ID, Value: Interrupt object with state
- */
-let interrupts = $state(new SvelteMap());
-// =========================================================================
-// Getter Functions (replace derived stores)
+// InterruptStore (per-instance reactive state)
 // =========================================================================
 /**
- * Get the reactive interrupts map.
- * Use this in components within $derived() for reactivity.
- */
-export function getInterruptsMap() {
-    return interrupts;
-}
-/**
- * Get pending interrupt IDs (interrupts not in a terminal state)
- */
-export function getPendingInterruptIds() {
-    const pending = [];
-    interrupts.forEach((interrupt, id) => {
-        if (!isTerminalState(interrupt.machineState)) {
-            pending.push(id);
-        }
-    });
-    return pending;
-}
-/**
- * Get pending interrupts array (interrupts not in a terminal state)
- */
-export function getPendingInterrupts() {
-    const pending = [];
-    interrupts.forEach((interrupt) => {
-        if (!isTerminalState(interrupt.machineState)) {
-            pending.push(interrupt);
-        }
-    });
-    return pending;
-}
-/**
- * Get count of pending interrupts
+ * 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 function getPendingInterruptCount() {
-    let count = 0;
-    for (const interrupt of interrupts.values()) {
-        if (!isTerminalState(interrupt.machineState))
-            count++;
+export class InterruptStore {
+    /**
+     * Reactive map of all interrupts by ID.
+     * Uses SvelteMap for deep reactivity with Svelte 5 runes.
+     * Key: interrupt ID, Value: Interrupt object with state
+     */
+    #interrupts = new SvelteMap();
+    /** Bound mutation facade — see {@link InterruptStoreActions}. */
+    actions;
+    constructor() {
+        this.actions = Object.freeze({
+            addInterrupt: this.addInterrupt.bind(this),
+            addInterrupts: this.addInterrupts.bind(this),
+            startSubmit: this.startSubmit.bind(this),
+            startCancel: this.startCancel.bind(this),
+            submitSuccess: this.submitSuccess.bind(this),
+            submitFailure: this.submitFailure.bind(this),
+            retry: this.retry.bind(this),
+            resetInterrupt: this.resetInterrupt.bind(this),
+            resolveInterrupt: this.resolveInterrupt.bind(this),
+            cancelInterrupt: this.cancelInterrupt.bind(this),
+            removeInterrupt: this.removeInterrupt.bind(this),
+            clearSessionInterrupts: this.clearSessionInterrupts.bind(this),
+            clearInterrupts: this.clearInterrupts.bind(this),
+            reset: this.reset.bind(this)
+        });
     }
-    return count;
-}
-/**
- * Get resolved interrupts array
- */
-export function getResolvedInterrupts() {
-    const resolved = [];
-    interrupts.forEach((interrupt) => {
-        if (interrupt.machineState.status === 'resolved') {
-            resolved.push(interrupt);
-        }
-    });
-    return resolved;
-}
-/**
- * Check if any interrupt is currently submitting
- */
-export function getIsAnySubmitting() {
-    for (const interrupt of interrupts.values()) {
-        if (checkIsSubmitting(interrupt.machineState)) {
-            return true;
+    // -----------------------------------------------------------------------
+    // Reactive getters (replace derived stores)
+    // -----------------------------------------------------------------------
+    /**
+     * Get the reactive interrupts map.
+     * Use this in components within $derived() for reactivity.
+     */
+    getMap() {
+        return this.#interrupts;
+    }
+    /**
+     * Get pending interrupt IDs (interrupts not in a terminal state)
+     */
+    getPendingIds() {
+        const pending = [];
+        this.#interrupts.forEach((interrupt, id) => {
+            if (!isTerminalState(interrupt.machineState)) {
+                pending.push(id);
+            }
+        });
+        return pending;
+    }
+    /**
+     * Get pending interrupts array (interrupts not in a terminal state)
+     */
+    getPending() {
+        const pending = [];
+        this.#interrupts.forEach((interrupt) => {
+            if (!isTerminalState(interrupt.machineState)) {
+                pending.push(interrupt);
+            }
+        });
+        return pending;
+    }
+    /**
+     * Get count of pending interrupts
+     */
+    getPendingCount() {
+        let count = 0;
+        for (const interrupt of this.#interrupts.values()) {
+            if (!isTerminalState(interrupt.machineState))
+                count++;
         }
+        return count;
     }
-    return false;
-}
-// =========================================================================
-// State Machine Actions
-// =========================================================================
-/**
- * Apply a state machine action to an interrupt
- *
- * @param interruptId - The interrupt ID
- * @param action - The action to apply
- * @returns Transition result with validity and any errors
- */
-function applyAction(interruptId, action) {
-    const interrupt = interrupts.get(interruptId);
-    if (!interrupt) {
-        return {
-            state: initialState,
-            valid: false,
-            error: `Interrupt not found: ${interruptId}`
-        };
+    /**
+     * Get resolved interrupts array
+     */
+    getResolved() {
+        const resolved = [];
+        this.#interrupts.forEach((interrupt) => {
+            if (interrupt.machineState.status === 'resolved') {
+                resolved.push(interrupt);
+            }
+        });
+        return resolved;
     }
-    const result = transition(interrupt.machineState, action);
-    if (result.valid) {
-        const current = interrupts.get(interruptId);
-        if (current) {
-            // Update machine state and sync legacy fields
-            const newInterrupt = {
-                ...current,
-                machineState: result.state,
-                status: toLegacyStatus(result.state),
-                responseValue: getResolvedValue(result.state) ?? current.responseValue,
-                resolvedAt: result.state.status === 'resolved'
-                    ? result.state.resolvedAt
-                    : result.state.status === 'cancelled'
-                        ? result.state.cancelledAt
-                        : current.resolvedAt
-            };
-            interrupts.set(interruptId, newInterrupt);
+    /**
+     * Check if any interrupt is currently submitting
+     */
+    getIsAnySubmitting() {
+        for (const interrupt of this.#interrupts.values()) {
+            if (checkIsSubmitting(interrupt.machineState)) {
+                return true;
+            }
         }
+        return false;
     }
-    else {
-        logger.warn(`[InterruptStore] Invalid transition: ${result.error}`);
+    // -----------------------------------------------------------------------
+    // State machine internals
+    // -----------------------------------------------------------------------
+    /**
+     * Apply a state machine action to an interrupt
+     *
+     * @param interruptId - The interrupt ID
+     * @param action - The action to apply
+     * @returns Transition result with validity and any errors
+     */
+    #applyAction(interruptId, action) {
+        const interrupt = this.#interrupts.get(interruptId);
+        if (!interrupt) {
+            return {
+                state: initialState,
+                valid: false,
+                error: `Interrupt not found: ${interruptId}`
+            };
+        }
+        const result = transition(interrupt.machineState, action);
+        if (result.valid) {
+            const current = this.#interrupts.get(interruptId);
+            if (current) {
+                // Update machine state and sync legacy fields
+                const newInterrupt = {
+                    ...current,
+                    machineState: result.state,
+                    status: toLegacyStatus(result.state),
+                    responseValue: getResolvedValue(result.state) ?? current.responseValue,
+                    resolvedAt: result.state.status === 'resolved'
+                        ? result.state.resolvedAt
+                        : result.state.status === 'cancelled'
+                            ? result.state.cancelledAt
+                            : current.resolvedAt
+                };
+                this.#interrupts.set(interruptId, newInterrupt);
+            }
+        }
+        else {
+            logger.warn(`[InterruptStore] Invalid transition: ${result.error}`);
+        }
+        return result;
     }
-    return result;
-}
-// =========================================================================
-// Public Actions
-// =========================================================================
-/**
- * Interrupt store actions for modifying state
- */
-export const interruptActions = {
+    // -----------------------------------------------------------------------
+    // Public actions
+    // -----------------------------------------------------------------------
     /**
      * Add or update an interrupt in the store
      *
      * @param interrupt - The interrupt to add or update
      */
-    addInterrupt: (interrupt) => {
-        const existing = interrupts.get(interrupt.id);
+    addInterrupt(interrupt) {
+        const existing = this.#interrupts.get(interrupt.id);
         // Preserve existing machine state if interrupt already exists
         const machineState = existing?.machineState ?? initialState;
         const interruptWithState = {
             ...interrupt,
             machineState
         };
-        interrupts.set(interrupt.id, interruptWithState);
-    },
+        this.#interrupts.set(interrupt.id, interruptWithState);
+    }
     /**
      * Add multiple interrupts to the store
      *
      * @param interruptList - Array of interrupts to add
      */
-    addInterrupts: (interruptList) => {
+    addInterrupts(interruptList) {
         if (interruptList.length === 0)
             return;
         interruptList.forEach((interrupt) => {
-            const existing = interrupts.get(interrupt.id);
+            const existing = this.#interrupts.get(interrupt.id);
             const machineState = existing?.machineState ?? initialState;
             const interruptWithState = {
                 ...interrupt,
                 machineState
             };
-            interrupts.set(interrupt.id, interruptWithState);
+            this.#interrupts.set(interrupt.id, interruptWithState);
         });
-    },
+    }
     /**
      * Start submitting an interrupt (user clicked submit)
      *
@@ -176,27 +203,27 @@ export const interruptActions = {
      * @param value - The value being submitted
      * @returns Transition result
      */
-    startSubmit: (interruptId, value) => {
-        return applyAction(interruptId, { type: 'SUBMIT', value });
-    },
+    startSubmit(interruptId, value) {
+        return this.#applyAction(interruptId, { type: 'SUBMIT', value });
+    }
     /**
      * Start cancelling an interrupt (user clicked cancel)
      *
      * @param interruptId - The interrupt ID
      * @returns Transition result
      */
-    startCancel: (interruptId) => {
-        return applyAction(interruptId, { type: 'CANCEL' });
-    },
+    startCancel(interruptId) {
+        return this.#applyAction(interruptId, { type: 'CANCEL' });
+    }
     /**
      * Mark submission as successful
      *
      * @param interruptId - The interrupt ID
      * @returns Transition result
      */
-    submitSuccess: (interruptId) => {
-        return applyAction(interruptId, { type: 'SUCCESS' });
-    },
+    submitSuccess(interruptId) {
+        return this.#applyAction(interruptId, { type: 'SUCCESS' });
+    }
     /**
      * Mark submission as failed
      *
@@ -204,148 +231,148 @@ export const interruptActions = {
      * @param error - Error message
      * @returns Transition result
      */
-    submitFailure: (interruptId, error) => {
-        return applyAction(interruptId, { type: 'FAILURE', error });
-    },
+    submitFailure(interruptId, error) {
+        return this.#applyAction(interruptId, { type: 'FAILURE', error });
+    }
     /**
      * Retry a failed submission
      *
      * @param interruptId - The interrupt ID
      * @returns Transition result
      */
-    retry: (interruptId) => {
-        return applyAction(interruptId, { type: 'RETRY' });
-    },
+    retry(interruptId) {
+        return this.#applyAction(interruptId, { type: 'RETRY' });
+    }
     /**
      * Reset an interrupt to idle state
      *
      * @param interruptId - The interrupt ID
      * @returns Transition result
      */
-    resetInterrupt: (interruptId) => {
-        return applyAction(interruptId, { type: 'RESET' });
-    },
+    resetInterrupt(interruptId) {
+        return this.#applyAction(interruptId, { type: 'RESET' });
+    }
     /**
      * Mark an interrupt as resolved with the user's response
      *
      * @param interruptId - The interrupt ID
      * @param value - The resolved value
      */
-    resolveInterrupt: (interruptId, value) => {
-        const submitResult = applyAction(interruptId, { type: 'SUBMIT', value });
+    resolveInterrupt(interruptId, value) {
+        const submitResult = this.#applyAction(interruptId, { type: 'SUBMIT', value });
         if (submitResult.valid) {
-            applyAction(interruptId, { type: 'SUCCESS' });
+            this.#applyAction(interruptId, { type: 'SUCCESS' });
         }
-    },
+    }
     /**
      * Mark an interrupt as cancelled
      *
      * @param interruptId - The interrupt ID
      */
-    cancelInterrupt: (interruptId) => {
-        const cancelResult = applyAction(interruptId, { type: 'CANCEL' });
+    cancelInterrupt(interruptId) {
+        const cancelResult = this.#applyAction(interruptId, { type: 'CANCEL' });
         if (cancelResult.valid) {
-            applyAction(interruptId, { type: 'SUCCESS' });
+            this.#applyAction(interruptId, { type: 'SUCCESS' });
         }
-    },
+    }
     /**
      * Remove an interrupt from the store
      *
      * @param interruptId - The interrupt ID to remove
      */
-    removeInterrupt: (interruptId) => {
-        interrupts.delete(interruptId);
-    },
+    removeInterrupt(interruptId) {
+        this.#interrupts.delete(interruptId);
+    }
     /**
      * Clear all interrupts for a specific session
      *
      * @param sessionId - The session ID to clear interrupts for
      */
-    clearSessionInterrupts: (sessionId) => {
+    clearSessionInterrupts(sessionId) {
         const toDelete = [];
-        interrupts.forEach((interrupt, id) => {
+        this.#interrupts.forEach((interrupt, id) => {
             if (interrupt.sessionId === sessionId) {
                 toDelete.push(id);
             }
         });
-        toDelete.forEach((id) => interrupts.delete(id));
-    },
+        toDelete.forEach((id) => this.#interrupts.delete(id));
+    }
     /**
      * Alias for clearSessionInterrupts
      */
-    clearInterrupts: () => {
-        interrupts.clear();
-    },
+    clearInterrupts() {
+        this.#interrupts.clear();
+    }
     /**
      * Reset all interrupt state
      */
-    reset: () => {
-        interrupts.clear();
+    reset() {
+        this.#interrupts.clear();
     }
-};
-// =========================================================================
-// Utilities
-// =========================================================================
-/**
- * Get an interrupt by ID
- *
- * @param interruptId - The interrupt ID
- * @returns The interrupt or undefined
- */
-export function getInterrupt(interruptId) {
-    return interrupts.get(interruptId);
-}
-/**
- * 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 function isInterruptPending(interruptId) {
-    const interrupt = interrupts.get(interruptId);
-    return interrupt ? !isTerminalState(interrupt.machineState) : false;
-}
-/**
- * Check if an interrupt is currently submitting
- *
- * @param interruptId - The interrupt ID
- * @returns True if the interrupt is being submitted
- */
-export function isInterruptSubmitting(interruptId) {
-    const interrupt = interrupts.get(interruptId);
-    return interrupt ? checkIsSubmitting(interrupt.machineState) : false;
-}
-/**
- * Get the error for an interrupt
- *
- * @param interruptId - The interrupt ID
- * @returns The error message or undefined
- */
-export function getInterruptError(interruptId) {
-    const interrupt = interrupts.get(interruptId);
-    return interrupt ? getErrorMessage(interrupt.machineState) : undefined;
-}
-/**
- * Get an interrupt by its associated message ID
- *
- * @param messageId - The message ID
- * @returns The interrupt or undefined
- */
-export function getInterruptByMessageId(messageId) {
-    for (const interrupt of interrupts.values()) {
-        if (interrupt.messageId === messageId) {
-            return interrupt;
+    // -----------------------------------------------------------------------
+    // Utilities
+    // -----------------------------------------------------------------------
+    /**
+     * Get an interrupt by ID
+     *
+     * @param interruptId - The interrupt ID
+     * @returns The interrupt or undefined
+     */
+    getInterrupt(interruptId) {
+        return this.#interrupts.get(interruptId);
+    }
+    /**
+     * 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) {
+        const interrupt = this.#interrupts.get(interruptId);
+        return interrupt ? !isTerminalState(interrupt.machineState) : false;
+    }
+    /**
+     * Check if an interrupt is currently submitting
+     *
+     * @param interruptId - The interrupt ID
+     * @returns True if the interrupt is being submitted
+     */
+    isSubmitting(interruptId) {
+        const interrupt = this.#interrupts.get(interruptId);
+        return interrupt ? checkIsSubmitting(interrupt.machineState) : false;
+    }
+    /**
+     * Get the error for an interrupt
+     *
+     * @param interruptId - The interrupt ID
+     * @returns The error message or undefined
+     */
+    getError(interruptId) {
+        const interrupt = this.#interrupts.get(interruptId);
+        return interrupt ? getErrorMessage(interrupt.machineState) : undefined;
+    }
+    /**
+     * Get an interrupt by its associated message ID
+     *
+     * @param messageId - The message ID
+     * @returns The interrupt or undefined
+     */
+    getByMessageId(messageId) {
+        for (const interrupt of this.#interrupts.values()) {
+            if (interrupt.messageId === messageId) {
+                return interrupt;
+            }
         }
+        return undefined;
+    }
+    /**
+     * Check if an interrupt has an error
+     *
+     * @param interruptId - The interrupt ID
+     * @returns True if the interrupt has an error
+     */
+    hasError(interruptId) {
+        const interrupt = this.#interrupts.get(interruptId);
+        return interrupt ? checkHasError(interrupt.machineState) : false;
     }
-    return undefined;
-}
-/**
- * Check if an interrupt has an error
- *
- * @param interruptId - The interrupt ID
- * @returns True if the interrupt has an error
- */
-export function interruptHasError(interruptId) {
-    const interrupt = interrupts.get(interruptId);
-    return interrupt ? checkHasError(interrupt.machineState) : false;
 }

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

@@ -1,6 +1,30 @@
-export declare function getPipelinePanelOpen(): boolean;
-export declare const pipelinePanelActions: {
+/**
+ * Pipeline Panel Store for FlowDrop (Svelte 5 Runes)
+ *
+ * Tracks whether the pipeline panel is open, persisting the choice to
+ * localStorage so it survives reloads.
+ *
+ * The reactive state lives in the {@link PipelinePanelStore} class — one per
+ * FlowDrop instance, resolved in components via `getInstance().pipelinePanel`.
+ *
+ * @module stores/pipelinePanelStore
+ */
+/**
+ * Per-instance pipeline panel open state.
+ *
+ * Reads go through the {@link isOpen} getter backed by `$state`, so they track
+ * reactively in templates and `$derived`.
+ */
+export declare class PipelinePanelStore {
+    #private;
+    /** @param instanceId - Instance id used to scope the localStorage key. */
+    constructor(instanceId: string);
+    /** Whether the pipeline panel is currently open (reactive). */
+    get isOpen(): boolean;
+    /** Initialize open state from localStorage. */
     init(): void;
+    /** Toggle the panel open/closed, persisting the new state. */
     toggle(): void;
+    /** Set the panel open state explicitly, persisting it. */
     setOpen(value: boolean): void;
-};
+}