@flowdrop/flowdrop 1.14.0 → 2.0.0-beta.1

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;
+}