@coji/durably-react 0.6.0

package/dist/index.d.ts

@@ -0,0 +1,284 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Durably, JobDefinition, Run } from '@coji/durably';
+import { ReactNode } from 'react';
+import { R as RunStatus, L as LogEntry, P as Progress } from './types-BDUvsa8u.js';
+export { D as DurablyEvent } from './types-BDUvsa8u.js';
+
+interface DurablyContextValue {
+    durably: Durably;
+}
+interface DurablyProviderProps {
+    /**
+     * Durably instance or Promise that resolves to one.
+     * The instance should already be initialized via `await durably.init()`.
+     *
+     * When passing a Promise, wrap the provider with Suspense or use the fallback prop.
+     *
+     * @example
+     * // With Suspense (recommended)
+     * <Suspense fallback={<Loading />}>
+     *   <DurablyProvider durably={durablyPromise}>
+     *     <App />
+     *   </DurablyProvider>
+     * </Suspense>
+     *
+     * @example
+     * // With fallback prop
+     * <DurablyProvider durably={durablyPromise} fallback={<Loading />}>
+     *   <App />
+     * </DurablyProvider>
+     */
+    durably: Durably | Promise<Durably>;
+    /**
+     * Fallback to show while waiting for the Durably Promise to resolve.
+     * This wraps the provider content in a Suspense boundary automatically.
+     */
+    fallback?: ReactNode;
+    children: ReactNode;
+}
+declare function DurablyProvider({ durably, fallback, children, }: DurablyProviderProps): react_jsx_runtime.JSX.Element;
+declare function useDurably(): DurablyContextValue;
+
+interface UseJobOptions {
+    /**
+     * Initial Run ID to subscribe to (for reconnection scenarios)
+     */
+    initialRunId?: string;
+    /**
+     * Automatically resume tracking any pending or running job on initialization.
+     * If a pending or running run exists for this job, the hook will subscribe to it.
+     * @default true
+     */
+    autoResume?: boolean;
+    /**
+     * Automatically switch to tracking the latest running job when a new run starts.
+     * When true, the hook will update to track any new run for this job as soon as it starts running.
+     * When false, the hook will only track the run that was triggered or explicitly set.
+     * @default true
+     */
+    followLatest?: boolean;
+}
+interface UseJobResult<TInput, TOutput> {
+    /**
+     * Trigger the job with the given input
+     */
+    trigger: (input: TInput) => Promise<{
+        runId: string;
+    }>;
+    /**
+     * Trigger and wait for completion
+     */
+    triggerAndWait: (input: TInput) => Promise<{
+        runId: string;
+        output: TOutput;
+    }>;
+    /**
+     * Current run status
+     */
+    status: RunStatus | null;
+    /**
+     * Output from completed run
+     */
+    output: TOutput | null;
+    /**
+     * Error message from failed run
+     */
+    error: string | null;
+    /**
+     * Logs collected during execution
+     */
+    logs: LogEntry[];
+    /**
+     * Current progress
+     */
+    progress: Progress | null;
+    /**
+     * Whether a run is currently running
+     */
+    isRunning: boolean;
+    /**
+     * Whether a run is pending
+     */
+    isPending: boolean;
+    /**
+     * Whether the run completed successfully
+     */
+    isCompleted: boolean;
+    /**
+     * Whether the run failed
+     */
+    isFailed: boolean;
+    /**
+     * Whether the run was cancelled
+     */
+    isCancelled: boolean;
+    /**
+     * Current run ID
+     */
+    currentRunId: string | null;
+    /**
+     * Reset all state
+     */
+    reset: () => void;
+}
+declare function useJob<TName extends string, TInput extends Record<string, unknown>, TOutput extends Record<string, unknown> | void>(jobDefinition: JobDefinition<TName, TInput, TOutput>, options?: UseJobOptions): UseJobResult<TInput, TOutput>;
+
+interface UseJobLogsOptions {
+    /**
+     * The run ID to subscribe to logs for
+     */
+    runId: string | null;
+    /**
+     * Maximum number of logs to keep (default: unlimited)
+     */
+    maxLogs?: number;
+}
+interface UseJobLogsResult {
+    /**
+     * Logs collected during execution
+     */
+    logs: LogEntry[];
+    /**
+     * Clear all logs
+     */
+    clearLogs: () => void;
+}
+/**
+ * Hook for subscribing to logs from a run.
+ * Use this when you only need logs, not full run status.
+ */
+declare function useJobLogs(options: UseJobLogsOptions): UseJobLogsResult;
+
+interface UseJobRunOptions {
+    /**
+     * The run ID to subscribe to
+     */
+    runId: string | null;
+}
+interface UseJobRunResult<TOutput = unknown> {
+    /**
+     * Current run status
+     */
+    status: RunStatus | null;
+    /**
+     * Output from completed run
+     */
+    output: TOutput | null;
+    /**
+     * Error message from failed run
+     */
+    error: string | null;
+    /**
+     * Logs collected during execution
+     */
+    logs: LogEntry[];
+    /**
+     * Current progress
+     */
+    progress: Progress | null;
+    /**
+     * Whether a run is currently running
+     */
+    isRunning: boolean;
+    /**
+     * Whether a run is pending
+     */
+    isPending: boolean;
+    /**
+     * Whether the run completed successfully
+     */
+    isCompleted: boolean;
+    /**
+     * Whether the run failed
+     */
+    isFailed: boolean;
+    /**
+     * Whether the run was cancelled
+     */
+    isCancelled: boolean;
+}
+/**
+ * Hook for subscribing to an existing run by ID.
+ * Use this when you have a runId and want to track its status.
+ */
+declare function useJobRun<TOutput = unknown>(options: UseJobRunOptions): UseJobRunResult<TOutput>;
+
+interface UseRunsOptions {
+    /**
+     * Filter by job name
+     */
+    jobName?: string;
+    /**
+     * Filter by status
+     */
+    status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    /**
+     * Number of runs per page
+     * @default 10
+     */
+    pageSize?: number;
+    /**
+     * Subscribe to real-time updates
+     * @default true
+     */
+    realtime?: boolean;
+}
+interface UseRunsResult {
+    /**
+     * List of runs for the current page
+     */
+    runs: Run[];
+    /**
+     * Current page (0-indexed)
+     */
+    page: number;
+    /**
+     * Whether there are more pages
+     */
+    hasMore: boolean;
+    /**
+     * Whether data is being loaded
+     */
+    isLoading: boolean;
+    /**
+     * Go to the next page
+     */
+    nextPage: () => void;
+    /**
+     * Go to the previous page
+     */
+    prevPage: () => void;
+    /**
+     * Go to a specific page
+     */
+    goToPage: (page: number) => void;
+    /**
+     * Refresh the current page
+     */
+    refresh: () => Promise<void>;
+}
+/**
+ * Hook for listing runs with pagination and real-time updates.
+ *
+ * @example
+ * ```tsx
+ * function Dashboard() {
+ *   const { runs, page, hasMore, nextPage, prevPage, isLoading } = useRuns({
+ *     pageSize: 20,
+ *   })
+ *
+ *   return (
+ *     <div>
+ *       {runs.map(run => (
+ *         <div key={run.id}>{run.jobName}: {run.status}</div>
+ *       ))}
+ *       <button onClick={prevPage} disabled={page === 0}>Prev</button>
+ *       <button onClick={nextPage} disabled={!hasMore}>Next</button>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useRuns(options?: UseRunsOptions): UseRunsResult;
+
+export { DurablyProvider, type DurablyProviderProps, LogEntry, Progress, RunStatus, type UseJobLogsOptions, type UseJobLogsResult, type UseJobOptions, type UseJobResult, type UseJobRunOptions, type UseJobRunResult, type UseRunsOptions, type UseRunsResult, useDurably, useJob, useJobLogs, useJobRun, useRuns };