@bodhiapp/bodhi-js-react-core 0.0.11

package/README.md

@@ -0,0 +1,34 @@
+# @bodhiapp/bodhi-js-react
+
+React bindings for Bodhi Browser SDK.
+
+## Installation
+
+```bash
+npm install @bodhiapp/bodhi-js-react
+```
+
+## Usage
+
+```typescript
+import { BodhiProvider, useBodhi } from '@bodhiapp/bodhi-js-react';
+import { WebUIClient } from '@bodhiapp/bodhi-js';
+
+const client = new WebUIClient('your-client-id');
+
+function App() {
+  return (
+    <BodhiProvider client={client}>
+      <YourComponents />
+    </BodhiProvider>
+  );
+}
+```
+
+## Documentation
+
+See [bodhi-browser/bodhi-js-sdk](https://github.com/BodhiSearch/bodhi-browser/tree/main/bodhi-js-sdk) for complete documentation.
+
+## License
+
+MIT

package/dist/bodhi-browser-ext/src/types/bodhiext.d.ts

@@ -0,0 +1,201 @@
+import { OpenAiApiError, PingResponse, CreateChatCompletionRequest, CreateChatCompletionResponse, CreateChatCompletionStreamResponse } from '@bodhiapp/ts-client';
+/**
+ * HTTP response wrapper - body can be success type OR error type
+ * Use isApiErrorResponse() to narrow the type based on status
+ */
+export interface ApiResponse<T = unknown> {
+    body: T | OpenAiApiError;
+    status: number;
+    headers: Record<string, string>;
+}
+/**
+ * Stream chunk returned by sendStreamRequest
+ *
+ * This is the chunk structure yielded by the ReadableStream from sendStreamRequest.
+ * Different from StreamChunkMessage which is the internal message wrapper.
+ */
+export interface StreamChunk {
+    body: unknown;
+    headers?: Record<string, string>;
+    status?: number;
+    done?: boolean;
+}
+/**
+ * Server state information returned by /bodhi/v1/info endpoint
+ */
+export interface ServerStateInfo {
+    /** Current application status */
+    status: 'setup' | 'ready' | 'resource-admin' | 'error' | 'unreachable';
+    /** Application version */
+    version?: string;
+    /** Server URL (added by extension) */
+    url?: string;
+    /** Error details if status is 'error' or 'unreachable' */
+    error?: {
+        message: string;
+        type?: string;
+        code?: string;
+        param?: string;
+    };
+}
+/**
+ * API error thrown when server returns HTTP 4xx/5xx
+ * Used for streaming responses (non-streaming returns ApiResponse)
+ */
+export interface ApiError extends Error {
+    response: {
+        status: number;
+        body: OpenAiApiError;
+        headers?: Record<string, string>;
+    };
+}
+/**
+ * Operation error thrown when HTTP request couldn't complete
+ * (network unreachable, timeout, extension error)
+ */
+export interface OperationError extends Error {
+    error: {
+        message: string;
+        type: string;
+    };
+}
+/**
+ * Union of all extension-thrown errors
+ */
+export type ExtensionError = ApiError | OperationError;
+/**
+ * Type guard: API error (has response field)
+ */
+export declare function isApiError(err: unknown): err is ApiError;
+/**
+ * Type guard: Operation error (has error field, no response)
+ */
+export declare function isOperationError(err: unknown): err is OperationError;
+/**
+ * Chat API uses types from @bodhiapp/ts-client.
+ * Consumers should import these types directly from @bodhiapp/ts-client:
+ * - ChatCompletionRequestMessage
+ * - ChatCompletionResponseMessage
+ * - CreateChatCompletionRequest
+ * - CreateChatCompletionResponse
+ * - CreateChatCompletionStreamResponse
+ * - ChatChoice
+ * - ChatChoiceStream
+ * - ChatCompletionStreamResponseDelta
+ */
+/**
+ * Chat completions API interface
+ */
+export interface ChatCompletionsApi {
+    /**
+     * Create a chat completion
+     *
+     * Non-streaming: Returns ApiResponse - caller checks status for success/error
+     * Streaming: Yields chunks via AsyncIterable - throws ApiError or OperationError on error
+     *
+     * @param params - Chat completion parameters
+     * @returns Non-streaming: Promise<ApiResponse<CreateChatCompletionResponse>>, Streaming: AsyncIterable<CreateChatCompletionStreamResponse>
+     */
+    create(params: CreateChatCompletionRequest & {
+        stream?: false;
+    }): Promise<ApiResponse<CreateChatCompletionResponse>>;
+    create(params: CreateChatCompletionRequest & {
+        stream: true;
+    }): AsyncIterable<CreateChatCompletionStreamResponse>;
+    create(params: CreateChatCompletionRequest): Promise<ApiResponse<CreateChatCompletionResponse>> | AsyncIterable<CreateChatCompletionStreamResponse>;
+}
+/**
+ * Chat API namespace
+ */
+export interface ChatApi {
+    completions: ChatCompletionsApi;
+}
+/**
+ * Public window.bodhiext interface
+ *
+ * This interface defines all methods available to web pages through window.bodhiext.
+ * The extension creates this interface in inject.ts and attaches it to the window object.
+ */
+export interface BodhiExtPublicApi {
+    /**
+     * Send a generic API request through the extension to the backend server.
+     *
+     * @template TReq - Request body type (inferred from body parameter)
+     * @template TRes - Response body type (must be specified explicitly)
+     * @param method - HTTP method (GET, POST, PUT, DELETE, etc.)
+     * @param endpoint - API endpoint path (e.g., '/v1/chat/completions')
+     * @param body - Optional request body (will be JSON stringified)
+     * @param headers - Optional additional headers
+     * @returns Promise resolving to ApiResponse with body, headers, and status
+     */
+    sendApiRequest<TReq = unknown, TRes = unknown>(method: string, endpoint: string, body?: TReq, headers?: Record<string, string>): Promise<ApiResponse<TRes>>;
+    /**
+     * Send a streaming API request through the extension.
+     *
+     * Used for SSE (Server-Sent Events) endpoints like streaming chat completions.
+     * Returns a ReadableStream that yields StreamChunk objects.
+     *
+     * @template TReq - Request body type (inferred from body parameter)
+     * @param method - HTTP method (typically POST for streaming)
+     * @param endpoint - API endpoint path (e.g., '/v1/chat/completions')
+     * @param body - Optional request body
+     * @param headers - Optional additional headers
+     * @returns ReadableStream yielding StreamChunk objects
+     */
+    sendStreamRequest<TReq = unknown>(method: string, endpoint: string, body?: TReq, headers?: Record<string, string>): ReadableStream<StreamChunk>;
+    /**
+     * Send a generic extension request.
+     *
+     * Used for extension-specific operations like test_connection, get_extension_id, etc.
+     * This is a low-level API for extension capabilities.
+     *
+     * @param action - Extension action name (e.g., 'test_connection')
+     * @param params - Optional action parameters
+     * @returns Promise resolving to action-specific response
+     */
+    sendExtRequest(action: string, params?: any): Promise<any>;
+    /**
+     * Simple health check to verify extension connectivity.
+     *
+     * Returns ApiResponse - caller should check status to determine success/error.
+     * On success (2xx), body is PingResponse. On error (4xx/5xx), body is OpenAiApiError.
+     *
+     * @returns Promise resolving to ApiResponse<PingResponse>
+     */
+    ping(): Promise<ApiResponse<PingResponse>>;
+    /**
+     * Get server state information from /bodhi/v1/info endpoint.
+     *
+     * Returns the current status of the backend server including
+     * whether it's in setup mode, ready, or has errors.
+     *
+     * @returns Promise resolving to ServerStateInfo
+     */
+    serverState(): Promise<ServerStateInfo>;
+    /**
+     * OpenAI-compatible chat API.
+     *
+     * Provides chat completion functionality compatible with OpenAI's API structure.
+     */
+    chat: ChatApi;
+    /**
+     * Get the extension ID.
+     *
+     * The extension ID is fetched asynchronously during initialization.
+     * This method returns a promise that resolves to the extension ID once available.
+     *
+     * @returns Promise resolving to the extension ID string
+     */
+    getExtensionId(): Promise<string>;
+}
+/**
+ * Window augmentation for TypeScript
+ *
+ * Declares the optional bodhiext property on the Window interface.
+ * This allows TypeScript code to access window.bodhiext with proper typing.
+ */
+declare global {
+    interface Window {
+        bodhiext?: BodhiExtPublicApi;
+    }
+}

package/dist/bodhi-browser-ext/src/types/common.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared constants for Bodhi Browser Extension
+ *
+ * Constants used by both inject.ts and background/content.ts scripts,
+ * or common to the entire extension.
+ */
+export declare const CONTENT_TYPE_JSON = "application/json";
+export declare const CONTENT_TYPE_EVENT_STREAM = "text/event-stream";
+export declare const CONTENT_TYPE_HEADER = "Content-Type";
+export declare const HTTP_METHOD_GET = "GET";
+export declare const HTTP_METHOD_POST = "POST";
+export declare const ENDPOINT_PING = "/ping";
+export declare const ENDPOINT_CHAT_COMPLETIONS = "/v1/chat/completions";
+export declare const DEFAULT_API_BASE_URL = "http://localhost:1135";
+export declare const DEFAULT_API_TIMEOUT = 10000;
+export declare const DEFAULT_STREAM_TIMEOUT = 60000;
+export declare const STORAGE_KEY_BACKEND_URL = "backendUrl";
+export declare const SSE_DONE_MARKER = "[DONE]";
+export declare const SSE_DATA_PREFIX = "data: ";
+export declare const SSE_CHUNK_DELIMITER = "\n\n";
+export declare const EXT_ACTIONS: {
+    readonly GET_EXTENSION_ID: "get_extension_id";
+    readonly TEST_CONNECTION: "test_connection";
+};
+export declare const ERROR_TYPES: {
+    readonly NETWORK_ERROR: "network_error";
+    readonly EXTENSION_ERROR: "extension_error";
+    readonly TIMEOUT_ERROR: "timeout_error";
+    readonly AUTH_ERROR: "auth_error";
+};
+export type ConnectionErrorType = (typeof ERROR_TYPES)[keyof typeof ERROR_TYPES];
+export declare const DOCUMENT_STATE_COMPLETE = "complete";
+export declare const EVENT_INITIALIZED = "bodhiext:initialized";
+export declare const BODHI_STREAM_PORT = "BODHI_STREAM_PORT";
+export declare const ORIGIN_WILDCARD = "*";
+export declare const ERROR_MISSING_REQUEST_ID = "Invalid message format: missing requestId or request";
+export declare const ERROR_CONNECTION_CLOSED = "Connection closed unexpectedly";

package/dist/bodhi-browser-ext/src/types/index.d.ts

@@ -0,0 +1,6 @@
+export type { ApiResponse, StreamChunk, ServerStateInfo, ApiError, OperationError, ExtensionError, ChatCompletionsApi, ChatApi, BodhiExtPublicApi } from './bodhiext';
+export { isApiError, isOperationError } from './bodhiext';
+export type { ApiRequest, ApiRequestMessage, OperationErrorResponse, ApiResponseSuccessMessage, OperationErrorResponseMessage, ApiResponseMessage, ErrorMessage, StreamChunkMessage, StreamApiErrorMessage, StreamErrorMessage, StreamMessage, StreamController, SSEChunk, ExtRequest, ExtRequestMessage, ExtError, ExtErrorResponse, ExtResponse, ExtResponseMessage, GetExtensionIdRequest, GetExtensionIdResponse, TestConnectionRequest, TestConnectionResponse, } from './protocol';
+export { MESSAGE_TYPES, isOperationErrorResponse, isApiErrorResponse, isApiSuccessResponse, isStreamChunk, isStreamApiError, isStreamError, isExtError, isOpenAiApiErrorBody, isOperationErrorStructure, } from './protocol';
+export { CONTENT_TYPE_JSON, CONTENT_TYPE_EVENT_STREAM, CONTENT_TYPE_HEADER, HTTP_METHOD_GET, HTTP_METHOD_POST, ENDPOINT_PING, ENDPOINT_CHAT_COMPLETIONS, DEFAULT_API_BASE_URL, DEFAULT_API_TIMEOUT, DEFAULT_STREAM_TIMEOUT, STORAGE_KEY_BACKEND_URL, SSE_DONE_MARKER, SSE_DATA_PREFIX, SSE_CHUNK_DELIMITER, EXT_ACTIONS, ERROR_TYPES, DOCUMENT_STATE_COMPLETE, EVENT_INITIALIZED, BODHI_STREAM_PORT, ORIGIN_WILDCARD, ERROR_MISSING_REQUEST_ID, ERROR_CONNECTION_CLOSED, } from './common';
+export type { ConnectionErrorType } from './common';

package/dist/bodhi-browser-ext/src/types/protocol.d.ts

@@ -0,0 +1,222 @@
+import { OpenAiApiError, ErrorBody } from '@bodhiapp/ts-client';
+import { ApiResponse, ServerStateInfo } from './bodhiext';
+/**
+ * Validate OpenAI API error body structure
+ * { error: { message: string, type: string } }
+ */
+export declare function isOpenAiApiErrorBody(body: unknown): body is OpenAiApiError;
+/**
+ * Validate OperationErrorResponse structure
+ * { message: string, type: string }
+ */
+export declare function isOperationErrorStructure(obj: unknown): obj is OperationErrorResponse;
+export declare const MESSAGE_TYPES: {
+    readonly API_REQUEST: "BODHI_API_REQUEST";
+    readonly API_RESPONSE: "BODHI_API_RESPONSE";
+    readonly STREAM_REQUEST: "BODHI_STREAM_REQUEST";
+    readonly STREAM_CHUNK: "BODHI_STREAM_CHUNK";
+    readonly STREAM_ERROR: "BODHI_STREAM_ERROR";
+    readonly STREAM_API_ERROR: "BODHI_STREAM_API_ERROR";
+    readonly ERROR: "BODHI_ERROR";
+    readonly EXT_REQUEST: "BODHI_EXT_REQUEST";
+    readonly EXT_RESPONSE: "BODHI_EXT_RESPONSE";
+};
+export interface ApiRequest<T = unknown> {
+    method: string;
+    endpoint: string;
+    body?: T;
+    headers?: Record<string, string>;
+}
+export interface ApiRequestMessage<TReq = unknown> {
+    type: string;
+    requestId: string;
+    request: ApiRequest<TReq>;
+}
+/**
+ * Operation-level error response (network unreachable, timeout, extension error)
+ * NOT an API error (those come through ApiResponse with OpenAiApiError body)
+ * This is a response type, not a thrown error
+ */
+export interface OperationErrorResponse {
+    message: string;
+    type: string;
+}
+/**
+ * Success API response message (HTTP request completed, regardless of status code)
+ */
+export interface ApiResponseSuccessMessage<T = unknown> {
+    type: string;
+    requestId: string;
+    response: ApiResponse<T>;
+}
+/**
+ * Operation error response message - HTTP request couldn't complete
+ */
+export interface OperationErrorResponseMessage {
+    type: string;
+    requestId: string;
+    error: OperationErrorResponse;
+}
+/**
+ * API response message - discriminated union
+ */
+export type ApiResponseMessage<T = unknown> = ApiResponseSuccessMessage<T> | OperationErrorResponseMessage;
+/**
+ * Type guard for operation error response
+ */
+export declare function isOperationErrorResponse(msg: ApiResponseMessage): msg is OperationErrorResponseMessage;
+/**
+ * Type guard to check if response is an API error (4xx/5xx)
+ * Narrows body type to OpenAiApiError
+ */
+export declare function isApiErrorResponse<T>(response: ApiResponse<T>): response is ApiResponse<T> & {
+    body: OpenAiApiError;
+    status: number;
+};
+/**
+ * Type guard to check if response is successful (2xx)
+ * Narrows body type to T
+ */
+export declare function isApiSuccessResponse<T>(response: ApiResponse<T>): response is ApiResponse<T> & {
+    body: T;
+    status: number;
+};
+export interface ErrorMessage {
+    type: string;
+    requestId: string;
+    response: {
+        body: ErrorBody;
+        status: number;
+        headers: Record<string, string>;
+    };
+}
+/**
+ * Stream chunk message - successful SSE chunk received
+ * Uses ApiResponse<T> wrapper for consistency with non-streaming pattern
+ */
+export interface StreamChunkMessage<T = unknown> {
+    type: typeof MESSAGE_TYPES.STREAM_CHUNK;
+    requestId: string;
+    response: ApiResponse<T>;
+}
+/**
+ * Stream API error message - server returned error response (not SSE)
+ * E.g., 400/401/500 JSON error instead of SSE stream
+ */
+export interface StreamApiErrorMessage {
+    type: typeof MESSAGE_TYPES.STREAM_API_ERROR;
+    requestId: string;
+    response: ApiResponse<OpenAiApiError>;
+}
+/**
+ * Stream error message - network/extension level error
+ * E.g., connection refused, timeout, extension error
+ */
+export interface StreamErrorMessage {
+    type: typeof MESSAGE_TYPES.STREAM_ERROR;
+    requestId: string;
+    error: OperationErrorResponse;
+}
+/**
+ * Union type for all streaming messages
+ */
+export type StreamMessage<T = unknown> = StreamChunkMessage<T> | StreamApiErrorMessage | StreamErrorMessage;
+/**
+ * Type guard for stream chunk message
+ */
+export declare function isStreamChunk<T>(msg: StreamMessage<T>): msg is StreamChunkMessage<T>;
+/**
+ * Type guard for stream API error
+ */
+export declare function isStreamApiError(msg: StreamMessage): msg is StreamApiErrorMessage;
+/**
+ * Type guard for stream error
+ */
+export declare function isStreamError(msg: StreamMessage): msg is StreamErrorMessage;
+/**
+ * Interface for stream controller to handle SSE responses
+ */
+export interface StreamController {
+    enqueue: (chunk: any) => void;
+    error: (err: Error) => void;
+    complete: () => void;
+}
+/**
+ * Interface for SSE data chunk
+ */
+export interface SSEChunk {
+    done?: boolean;
+    [key: string]: any;
+}
+/**
+ * Generic extension request interface
+ */
+export interface ExtRequest {
+    action: string;
+    params?: any;
+}
+/**
+ * Generic extension request message
+ */
+export interface ExtRequestMessage {
+    type: 'BODHI_EXT_REQUEST';
+    requestId: string;
+    request: ExtRequest;
+}
+/**
+ * Extension-level error structure
+ */
+export interface ExtError {
+    message: string;
+    type?: string;
+}
+/**
+ * Error response for extension operations
+ */
+export interface ExtErrorResponse {
+    error: ExtError;
+}
+/**
+ * Union type for extension response (flattened - no wrapper for success)
+ * Success: T (the actual response data)
+ * Error: { error: ExtError }
+ */
+export type ExtResponse<T = unknown> = T | ExtErrorResponse;
+/**
+ * Type guard to check if extension response is an error
+ */
+export declare function isExtError<T>(res: ExtResponse<T>): res is ExtErrorResponse;
+/**
+ * Generic extension response message
+ */
+export interface ExtResponseMessage<T = unknown> {
+    type: 'BODHI_EXT_RESPONSE';
+    requestId: string;
+    response: ExtResponse<T>;
+}
+/**
+ * Get Extension ID request (no params needed)
+ */
+export interface GetExtensionIdRequest extends ExtRequest {
+    action: 'get_extension_id';
+    params?: undefined;
+}
+/**
+ * Get Extension ID response body
+ */
+export interface GetExtensionIdResponse {
+    extension_id: string;
+}
+/**
+ * Test Connection request
+ */
+export interface TestConnectionRequest extends ExtRequest {
+    action: 'test_connection';
+    params: {
+        url: string;
+    };
+}
+/**
+ * Test Connection response body (reuses ServerStateInfo)
+ */
+export type TestConnectionResponse = ServerStateInfo;

package/dist/bodhi-js-sdk/react-core/src/BodhiProvider.d.ts

@@ -0,0 +1,35 @@
+import { AuthState, LogLevel, UIClient } from '../../core/src/index.ts';
+import { ReactNode } from 'react';
+import { ClientContextState } from './client-ctx';
+export type SetupState = 'ready' | 'loading' | 'loaded';
+export interface BodhiProviderProps {
+    children: ReactNode;
+    client: UIClient;
+    modalHtmlPath?: string;
+    handleCallback?: boolean;
+    callbackPath?: string;
+    basePath?: string;
+    logLevel?: LogLevel;
+}
+export interface BodhiContext {
+    client: UIClient;
+    clientState: ClientContextState;
+    setupState: SetupState;
+    auth: AuthState;
+    isAuthLoading: boolean;
+    login: () => Promise<void>;
+    logout: () => Promise<void>;
+    showSetup: () => Promise<void>;
+    hideSetup: () => void;
+    isAuthenticated: boolean;
+    canLogin: boolean;
+    isReady: boolean;
+    isServerReady: boolean;
+    isOverallReady: boolean;
+    isInitializing: boolean;
+    isExtension: boolean;
+    isDirect: boolean;
+}
+export declare const BodhiReactContext: import('react').Context<BodhiContext | null>;
+export declare function BodhiProvider({ children, client, modalHtmlPath, handleCallback, callbackPath, basePath, logLevel, }: BodhiProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useBodhi(): BodhiContext;

package/dist/bodhi-js-sdk/react-core/src/SetupModalProcessor.d.ts

@@ -0,0 +1,16 @@
+import { UIClient, LogLevel } from '../../core/src/index.ts';
+import { SetupState } from './BodhiProvider';
+interface SetupModalProcessorProps {
+    client: UIClient;
+    modalHtmlPath?: string;
+    hideSetup: () => void;
+    onSetupReady?: () => void;
+    setupState: SetupState;
+    basePath?: string;
+    logLevel?: LogLevel;
+}
+/**
+ * SetupModalProcessor - Headless React component managing setup modal business logic
+ */
+export declare function SetupModalProcessor({ client, modalHtmlPath, hideSetup, onSetupReady, setupState, basePath, logLevel, }: SetupModalProcessorProps): null;
+export {};

package/dist/bodhi-js-sdk/react-core/src/api/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Re-export all OpenAI-compatible types from @bodhiapp/bodhi-js-core/api
+ *
+ * Usage:
+ * import type { CreateChatCompletionRequest, Model } from '@bodhiapp/bodhi-js-react-core/api';
+ */
+export * from '../../../core/src/index.ts/api';

package/dist/bodhi-js-sdk/react-core/src/build-info.d.ts

@@ -0,0 +1 @@
+export declare const BUILD_MODE: string;

package/dist/bodhi-js-sdk/react-core/src/client-ctx.d.ts

@@ -0,0 +1,26 @@
+import { BackendServerState, ClientState } from '../../core/src/index.ts';
+import { OperationErrorResponse } from '../../../bodhi-browser-ext/src/types';
+export type ClientContextStatus = 'not-initialized' | 'initializing' | 'extension-not-found' | 'direct-not-connected' | 'ready';
+export interface ClientContextState {
+    status: ClientContextStatus;
+    mode: 'extension' | 'direct' | null;
+    extensionId: string | null;
+    url: string | null;
+    server: BackendServerState;
+    error: OperationErrorResponse | null;
+}
+export declare const INITIAL_CLIENT_CONTEXT_STATE: ClientContextState;
+export declare const INITIALIZING_CLIENT_CONTEXT_STATE: ClientContextState;
+export declare function isClientCtxNotInitialized(state: ClientContextState): boolean;
+export declare function isClientCtxInitializing(state: ClientContextState): boolean;
+export declare function isClientCtxInitialized(state: ClientContextState): boolean;
+export declare function isClientCtxReady(state: ClientContextState): boolean;
+export declare function isOverallReady(state: ClientContextState): boolean;
+export declare function clientStateToContextState(state: ClientState): ClientContextState;
+export declare const ClientCtxState: {
+    readonly isNotInitialized: typeof isClientCtxNotInitialized;
+    readonly isInitializing: typeof isClientCtxInitializing;
+    readonly isInitialized: typeof isClientCtxInitialized;
+    readonly isReady: typeof isClientCtxReady;
+    readonly isOverallReady: typeof isOverallReady;
+};

package/dist/bodhi-js-sdk/react-core/src/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @bodhiapp/bodhi-js-react - React bindings for Bodhi SDK
+ *
+ * Public API exports - minimal surface area following industry best practices
+ */
+export { BodhiProvider, BodhiReactContext, useBodhi, type BodhiContext, type BodhiProviderProps, type SetupState, } from './BodhiProvider';
+export type { ClientContextState, ClientContextStatus } from './client-ctx';
+export { INITIAL_CLIENT_CONTEXT_STATE, INITIALIZING_CLIENT_CONTEXT_STATE } from './client-ctx';
+export { ClientCtxState, clientStateToContextState, isClientCtxInitialized, isClientCtxInitializing, isClientCtxNotInitialized, isClientCtxReady, isOverallReady, } from './client-ctx';
+export type { ApiResponseResult, ClientState } from '../../core/src/index.ts';
+export { isApiResultError, isApiResultOperationError, isApiResultSuccess, isDirectState, isExtensionState, isWebUIClient, } from '../../core/src/index.ts';
+export { createApiError, createOperationError } from '../../core/src/index.ts';
+export type { AuthState, UIClient } from '../../core/src/index.ts';
+export { isAuthError, isAuthLoading, isAuthenticated, isClientReady, } from '../../core/src/index.ts';
+export { isOperationError, type OperationError } from '../../core/src/index.ts';
+export { BUILD_MODE as REACT_CORE_BUILD_MODE } from './build-info';

package/dist/bodhi-react-core.cjs.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const k=require("react/jsx-runtime"),s=require("@bodhiapp/bodhi-js-core"),r=require("react"),p={MODAL_READY:"modal:ready",MODAL_REFRESH:"modal:refresh",MODAL_CLOSE:"modal:close",MODAL_COMPLETE:"modal:complete",MODAL_LNA_CONNECT:"modal:lna:connect",MODAL_LNA_SKIP:"modal:lna:skip",MODAL_CONFIRM_SERVER_INSTALL:"modal:confirm-server-install",MODAL_SELECT_CONNECTION:"modal:select-connection"};function H({client:e,modalHtmlPath:i,hideSetup:L,onSetupReady:_,setupState:R,basePath:m="/",logLevel:A="warn"}){const y=R!=="ready",O=r.useMemo(()=>new s.Logger("SetupModalProcessor",A),[A]),l=r.useRef(null),u=r.useMemo(()=>new s.BodhiClientUserPrefsManager(s.createStoragePrefixWithBasePath(m,"bodhijs:")),[m]),C=r.useRef(null),E=r.useCallback(t=>t==="direct"?"lna":t==="extension"?"extension":null,[]),v=r.useCallback(t=>t.extension==="ready"?{status:"ready",version:"unknown",id:t.extensionId}:t.extension==="not-found"?{status:"not-installed",error:{message:"Extension not found",code:"ext-not-installed"}}:{status:"unreachable",error:{message:"Client not initialized",code:"ext-connection-failed"}},[]),b=r.useCallback(t=>{if(t.server.status==="pending-extension-ready")return{status:"pending-extension-ready",error:{message:"Extension not ready",code:"server-pending-ext-ready"}};const n=t.server;switch(n.status){case"ready":return{status:"ready",version:n.version||"unknown"};case"setup":return{status:"setup",version:n.version||"unknown",error:{message:n.error?.message||"Setup required",code:"server-in-setup-status"}};case"resource-admin":return{status:"resource-admin",version:n.version||"unknown",error:{message:n.error?.message||"Resource admin required",code:"server-in-admin-status"}};case"error":return{status:"error",error:{message:n.error?.message||"Unknown error",code:"server-unexpected-error"}};case"not-reachable":return{status:"unreachable",error:{message:n.error?.message||"Server not reachable",code:"server-conn-refused"}};default:return{status:"unreachable",error:{message:"Unknown server status",code:"server-unexpected-error"}}}},[]),g=r.useCallback(t=>{if(t.server.status==="not-connected")return{status:"pending-lna-ready"};const n=t.server;switch(n.status){case"ready":return{status:"ready",version:n.version||"unknown"};case"setup":return{status:"setup",version:n.version||"unknown"};case"resource-admin":return{status:"resource-admin",version:n.version||"unknown"};case"error":case"not-reachable":return{status:"error",error:{message:n.error?.message||"Connection error"}};default:return{status:"error",error:{message:"Unknown server status"}}}},[]),I=r.useCallback((t,n)=>{if(t.server.status!=="pending-extension-ready"){const o=t.server.status;if(o==="ready"||o==="setup"||o==="resource-admin")return!0}if(n.server.status!=="not-connected"){const o=n.server.status;if(o==="ready"||o==="setup"||o==="resource-admin")return!0}return!1},[]),h=r.useCallback((t,n,o)=>{if(n==="skipped")return{status:"skipped",serverUrl:o};if(t.server.status!=="not-connected"){const d=t.server;return d.status==="ready"||d.status==="setup"||d.status==="resource-admin"?{status:"granted",serverUrl:o}:{status:"unreachable",serverUrl:o,error:{message:d.error?.message||"Server unreachable",code:"lna-unreachable"}}}return n==="granted"?{status:"granted",serverUrl:o}:{status:"prompt",serverUrl:o}},[]),S=r.useCallback(async(t=!1)=>{const n=s.detectBrowser().type,o=s.detectOS().type;let d=await e.getExtensionState();(d.extension==="not-initialized"||t)&&(d=await e.testExtensionConnectivity());let a=await e.getDirectState();const c=u.getDirectStatus();c==="granted"&&(a.server.status==="not-connected"||t)&&(a=await e.testDirectConnectivity());const w=s.getServerUrl(a)||"http://localhost:1135",x=h(a,c,w);return e.getConnectionMode()===null&&(s.isDirectServerReady(a)?await e.setConnectionMode("direct"):s.isExtensionServerReady(d)&&await e.setConnectionMode("extension")),u.isServerInstallConfirmed()||I(d,a)&&u.setServerInstallConfirmed(!0),{extension:v(d),server:b(d),lna:x,lnaServer:g(a),env:{browser:n,os:o},browsers:s.BROWSER_CONFIGS,os:s.OS_CONFIGS,userConfirmations:{serverInstall:u.isServerInstallConfirmed()},selectedConnection:E(e.getConnectionMode())}},[e,u,v,b,g,E,h,I]),f=r.useCallback(()=>{if(!C.current)throw new Error("Cannot get state: currentStateRef is null");return{...C.current,userConfirmations:{serverInstall:u.isServerInstallConfirmed()},selectedConnection:E(e.getConnectionMode())}},[u,e,E]),T=r.useMemo(()=>({[p.MODAL_READY]:async()=>(O.info("MODAL_READY: building initial state"),{setupState:f()}),[p.MODAL_REFRESH]:async()=>{O.info("MODAL_REFRESH: refreshing state");const t=await S(!0);C.current=t;const n=f();return O.info(`MODAL_REFRESH: state refreshed
+`,JSON.stringify(n,null,2)),l.current?.updateState(f()),{setupState:n}},[p.MODAL_LNA_CONNECT]:async t=>{const n=t.payload.serverUrl;console.log("[SetupModalProcessor] LNA connect:",n);const o=await e.testDirectConnectivity(n);if(o.server.status!=="not-connected"){const a=o.server.status;if(a==="ready"||a==="setup"||a==="resource-admin"){u.setDirectStatus("granted"),e.getConnectionMode()===null&&await e.setConnectionMode("direct");const c=await S();return C.current=c,l.current?.updateState(f()),{success:!0}}}const d=await S();return C.current=d,l.current?.updateState(f()),{success:!1}},[p.MODAL_LNA_SKIP]:async()=>{u.setDirectStatus("skipped");const t=await S();return C.current=t,l.current?.updateState(f()),{success:!0}},[p.MODAL_CLOSE]:()=>{L()},[p.MODAL_COMPLETE]:()=>{L()},[p.MODAL_CONFIRM_SERVER_INSTALL]:t=>(u.setServerInstallConfirmed(t.payload.confirmed),l.current?.updateState(f()),{success:!0}),[p.MODAL_SELECT_CONNECTION]:async t=>{const o=t.payload.connection==="lna"?"direct":"extension";return await e.setConnectionMode(o),l.current?.updateState(f()),{success:!0}}}),[O,e,u,S,f,g,L]);return r.useEffect(()=>(l.current=new s.OnboardingModal({modalHtmlPath:i,handlers:T}),()=>{l.current?.destroy(),l.current=null}),[i,T]),r.useEffect(()=>{y&&l.current?S(!0).then(t=>{C.current=t,l.current?.show(t),_?.()}).catch(t=>{console.error("[SetupModalProcessor] buildSetupState failed:",t)}):!y&&l.current&&l.current.destroy()},[y,S,_]),null}const P={status:"not-initialized",mode:null,extensionId:null,url:null,server:s.BACKEND_SERVER_NOT_CONNECTED,error:null},z={status:"initializing",mode:null,extensionId:null,url:null,server:s.BACKEND_SERVER_NOT_CONNECTED,error:null};function B(e){return e.status==="not-initialized"}function j(e){return e.status==="initializing"}function U(e){return e.status!=="not-initialized"&&e.status!=="initializing"}function D(e){return e.status==="ready"}function F(e){return D(e)&&e.server.status==="ready"}function G(e){return s.isExtensionState(e)?{status:e.extension==="not-initialized"?"initializing":e.extension==="not-found"?"extension-not-found":"ready",mode:"extension",extensionId:e.extensionId,url:null,server:e.server,error:e.server.error}:{status:e.url===null?"direct-not-connected":"ready",mode:"direct",extensionId:null,url:e.url,server:e.server,error:e.server.error}}const K={isNotInitialized:B,isInitializing:j,isInitialized:U,isReady:D,isOverallReady:F},N=r.createContext(null);N.displayName="BodhiContext";function V({children:e,client:i,modalHtmlPath:L,handleCallback:_=!0,callbackPath:R="/callback",basePath:m="/",logLevel:A="warn"}){const y=r.useMemo(()=>new s.Logger("BodhiProvider",A),[A]),O=r.useRef(!1),l=r.useRef(!1),[u,C]=r.useState(P),[E,v]=r.useState(s.INITIAL_AUTH_STATE),[b,g]=r.useState(!1),[I,h]=r.useState("ready");r.useEffect(()=>{const a=c=>{switch(c.type){case"client-state":C(G(c.state));break;case"auth-state":v(c.state),g(!1);break}};return i.setStateCallback(a),()=>{i.setStateCallback(s.NOOP_STATE_CALLBACK)}},[i]);const S=r.useCallback(async()=>{h("loading")},[]),f=r.useCallback(()=>{h("ready")},[]),T=r.useCallback(()=>{h("loaded")},[]),t=r.useCallback(async a=>{C(z);try{await i.init(a||{})}catch(c){y.error("Init failed:",c)}},[i,y]);r.useEffect(()=>{if(l.current)return;l.current=!0,(async()=>{if(await t(),!_)return;const c=new URL(window.location.href);if(c.pathname!==R)return;const M=c.searchParams.get("code"),w=c.searchParams.get("state");!M||!w||O.current||(O.current=!0,s.isWebUIClient(i)&&(g(!0),i.handleOAuthCallback(M,w).then(()=>{window.history.replaceState({},"",m)}).catch(x=>{y.error("OAuth callback failed:",x),v({status:"error",user:null,accessToken:null,error:{message:x instanceof Error?x.message:"OAuth callback failed",code:"OAUTH_CALLBACK_FAILED"}}),g(!1),window.history.replaceState({},"",m)})))})()},[t,i,_,R,m]);const n=r.useCallback(async()=>{g(!0);try{await i.login()}catch(a){v({status:"error",user:null,accessToken:null,error:{message:a instanceof Error?a.message:"Login failed",code:"LOGIN_FAILED"}}),g(!1)}},[i]),o=r.useCallback(async()=>{try{await i.logout()}catch(a){v({status:"error",user:null,accessToken:null,error:{message:a instanceof Error?a.message:"Logout failed",code:"LOGOUT_FAILED"}})}},[i]),d=r.useMemo(()=>{const a=u.status==="ready",c=u.server.status==="ready";return{client:i,clientState:u,auth:E,isAuthLoading:b,login:n,logout:o,showSetup:S,hideSetup:f,setupState:I,isAuthenticated:E.status==="authenticated",canLogin:a&&!b,isReady:a,isServerReady:c,isOverallReady:a&&c,isInitializing:u.status==="initializing",isExtension:u.mode==="extension",isDirect:u.mode==="direct"}},[i,u,E,b,I,n,o,S,f]);return k.jsxs(N.Provider,{value:d,children:[k.jsx(H,{client:i,modalHtmlPath:L,hideSetup:f,onSetupReady:T,setupState:I,basePath:m,logLevel:A}),e]})}function W(){const e=r.useContext(N);if(!e)throw new Error("useBodhi must be used within BodhiProvider");return e}const q="production";Object.defineProperty(exports,"createApiError",{enumerable:!0,get:()=>s.createApiError});Object.defineProperty(exports,"createOperationError",{enumerable:!0,get:()=>s.createOperationError});Object.defineProperty(exports,"isApiResultError",{enumerable:!0,get:()=>s.isApiResultError});Object.defineProperty(exports,"isApiResultOperationError",{enumerable:!0,get:()=>s.isApiResultOperationError});Object.defineProperty(exports,"isApiResultSuccess",{enumerable:!0,get:()=>s.isApiResultSuccess});Object.defineProperty(exports,"isAuthError",{enumerable:!0,get:()=>s.isAuthError});Object.defineProperty(exports,"isAuthLoading",{enumerable:!0,get:()=>s.isAuthLoading});Object.defineProperty(exports,"isAuthenticated",{enumerable:!0,get:()=>s.isAuthenticated});Object.defineProperty(exports,"isClientReady",{enumerable:!0,get:()=>s.isClientReady});Object.defineProperty(exports,"isDirectState",{enumerable:!0,get:()=>s.isDirectState});Object.defineProperty(exports,"isExtensionState",{enumerable:!0,get:()=>s.isExtensionState});Object.defineProperty(exports,"isOperationError",{enumerable:!0,get:()=>s.isOperationError});Object.defineProperty(exports,"isWebUIClient",{enumerable:!0,get:()=>s.isWebUIClient});exports.BodhiProvider=V;exports.BodhiReactContext=N;exports.ClientCtxState=K;exports.INITIALIZING_CLIENT_CONTEXT_STATE=z;exports.INITIAL_CLIENT_CONTEXT_STATE=P;exports.REACT_CORE_BUILD_MODE=q;exports.clientStateToContextState=G;exports.isClientCtxInitialized=U;exports.isClientCtxInitializing=j;exports.isClientCtxNotInitialized=B;exports.isClientCtxReady=D;exports.isOverallReady=F;exports.useBodhi=W;

package/dist/bodhi-react-core.esm.d.ts

@@ -0,0 +1,2 @@
+export * from './bodhi-js-sdk/react-core/src/index'
+export {}