@bodhiapp/bodhi-js-react-core 0.0.11

package/dist/setup-modal/src/types/message-types.d.ts

@@ -0,0 +1,168 @@
+import { SetupState } from './state';
+/**
+ * Central registry mapping message types to their payload/response shapes
+ * Single source of truth - everything else is inferred!
+ */
+export interface MessageTypeRegistry {
+    /**
+     * Modal is ready and requesting initial state
+     * Sent on modal mount
+     */
+    'modal:ready': {
+        request: void;
+        response: {
+            setupState: SetupState;
+        };
+    };
+    /**
+     * User requested to refresh platform detection
+     * Triggers re-detection of browser, OS, extension, server
+     */
+    'modal:refresh': {
+        request: void;
+        response: {
+            setupState: SetupState;
+        };
+    };
+    /**
+     * User requested to close the modal
+     * Parent should hide/destroy modal
+     */
+    'modal:close': {
+        request: void;
+        response: void;
+    };
+    /**
+     * Setup completed successfully
+     * Signals parent that user has finished setup
+     */
+    'modal:complete': {
+        request: void;
+        response: void;
+    };
+    /**
+     * User requested LNA connection to specific server URL
+     * Triggers LNA permission request and connection attempt
+     */
+    'modal:lna:connect': {
+        request: {
+            serverUrl: string;
+        };
+        response: {
+            success: boolean;
+        };
+    };
+    /**
+     * User chose to skip LNA setup
+     * Falls back to extension-only mode
+     */
+    'modal:lna:skip': {
+        request: void;
+        response: {
+            success: boolean;
+        };
+    };
+    /**
+     * User confirmed server installation status
+     * Used when server needs to be installed
+     */
+    'modal:confirm-server-install': {
+        request: {
+            confirmed: boolean;
+        };
+        response: {
+            success: boolean;
+        };
+    };
+    /**
+     * User selected preferred connection method
+     * Allows choosing between LNA and Extension paths
+     */
+    'modal:select-connection': {
+        request: {
+            connection: 'lna' | 'extension';
+        };
+        response: {
+            success: boolean;
+        };
+    };
+    /**
+     * Parent sending updated state to modal
+     * Fired when platform detection results change
+     */
+    'parent:state-update': {
+        request: {
+            setupState: SetupState;
+        };
+        response: void;
+    };
+}
+/**
+ * Union of all valid message type strings
+ * Derived from MessageTypeRegistry keys
+ */
+export type MessageType = keyof MessageTypeRegistry;
+/**
+ * Extract request payload type for a given message type
+ * Returns the 'request' field from the registry entry
+ */
+export type RequestPayload<T extends MessageType> = MessageTypeRegistry[T]['request'];
+/**
+ * Extract response payload type for a given message type
+ * Returns the 'response' field from the registry entry
+ */
+export type ResponsePayload<T extends MessageType> = MessageTypeRegistry[T]['response'];
+/**
+ * Message type constants - Type-safe identifiers
+ *
+ * @example
+ * switch (message.type) {
+ *   case MSG.MODAL_READY:
+ *     // Type-safe constant, no typos possible
+ *     break;
+ * }
+ */
+export declare const MSG: {
+    readonly MODAL_READY: "modal:ready";
+    readonly MODAL_REFRESH: "modal:refresh";
+    readonly MODAL_CLOSE: "modal:close";
+    readonly MODAL_COMPLETE: "modal:complete";
+    readonly MODAL_LNA_CONNECT: "modal:lna:connect";
+    readonly MODAL_LNA_SKIP: "modal:lna:skip";
+    readonly MODAL_CONFIRM_SERVER_INSTALL: "modal:confirm-server-install";
+    readonly MODAL_SELECT_CONNECTION: "modal:select-connection";
+    readonly PARENT_STATE_UPDATE: "parent:state-update";
+};
+/**
+ * Type guard that narrows RequestMessage to specific type WITH payload typing
+ *
+ * Use this for full type safety when you need access to typed payload fields.
+ * The guard narrows the generic RequestMessage to RequestMessage<T> where T
+ * determines the payload type.
+ *
+ * @example
+ * if (isMessageType(msg, MSG.MODAL_LNA_CONNECT)) {
+ *   // msg.payload is { serverUrl: string } - fully typed!
+ *   console.log(msg.payload.serverUrl); // Autocomplete works!
+ * }
+ */
+export declare function isMessageType<T extends MessageType>(msg: {
+    type: string;
+}, type: T): msg is {
+    type: T;
+};
+/**
+ * Type-safe request handler map
+ * Enforces correct payload access AND correct return type for each message
+ *
+ * Each handler receives a RequestMessage<K> where K is the specific message type,
+ * providing full type safety for payload access. The handler must return the
+ * correct ResponsePayload<K> type.
+ */
+export type RequestHandlers = {
+    [K in MessageType]?: (msg: {
+        type: K;
+        requestId: string;
+        payload: RequestPayload<K>;
+    }) => ResponsePayload<K>;
+};

package/dist/setup-modal/src/types/platform.d.ts

@@ -0,0 +1,32 @@
+export type BrowserType = 'chrome' | 'edge' | 'firefox' | 'safari' | 'unknown';
+export type OSType = 'macos' | 'windows' | 'linux' | 'unknown';
+export interface EnvState {
+    os: OSType;
+    browser: BrowserType;
+}
+export interface SupportedBrowser {
+    id: BrowserType;
+    status: 'supported';
+    name: string;
+    extension_url: string;
+}
+export interface NotSupportedBrowser {
+    id: BrowserType;
+    status: 'not-supported';
+    name: string;
+    github_issue_url?: string;
+}
+export type Browser = SupportedBrowser | NotSupportedBrowser;
+export interface SupportedOS {
+    id: OSType;
+    status: 'supported';
+    name: string;
+    download_url: string;
+}
+export interface NotSupportedOS {
+    id: OSType;
+    status: 'not-supported';
+    name: string;
+    github_issue_url?: string;
+}
+export type OS = SupportedOS | NotSupportedOS;

package/dist/setup-modal/src/types/protocol.d.ts

@@ -0,0 +1,70 @@
+import { MessageType, RequestPayload, ResponsePayload } from './message-types';
+/** Branded type for type-safe request IDs */
+export type RequestId = string & {
+    readonly __brand: 'RequestId';
+};
+/** Message kind discriminator */
+export type MessageKind = 'request' | 'response' | 'error' | 'event';
+/**
+ * Request message - expects a response
+ * Sent by either modal or parent to request an action
+ */
+export interface RequestMessage<T extends MessageType = MessageType> {
+    readonly kind: 'request';
+    readonly type: T;
+    readonly requestId: RequestId;
+    readonly payload: RequestPayload<T>;
+}
+/**
+ * Response message - correlates to a request
+ * Sent in response to a RequestMessage with matching requestId
+ */
+export interface ResponseMessage<T extends MessageType = MessageType> {
+    readonly kind: 'response';
+    readonly type: T;
+    readonly requestId: RequestId;
+    readonly payload: ResponsePayload<T>;
+}
+/**
+ * Error response - indicates request failure
+ * Sent instead of ResponseMessage when request cannot be fulfilled
+ */
+export interface ErrorMessage {
+    readonly kind: 'error';
+    readonly requestId: RequestId;
+    readonly error: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+}
+/**
+ * Event message - fire-and-forget notification
+ * No response expected, used for one-way state updates
+ */
+export interface EventMessage<T extends MessageType = MessageType> {
+    readonly kind: 'event';
+    readonly type: T;
+    readonly payload: RequestPayload<T>;
+}
+/**
+ * Union of all protocol messages
+ * Discriminated by 'kind' field for type narrowing
+ */
+export type ProtocolMessage = RequestMessage | ResponseMessage | ErrorMessage | EventMessage;
+/**
+ * Type guard to check if message is a request
+ */
+export declare function isRequestMessage(msg: ProtocolMessage): msg is RequestMessage;
+/**
+ * Type guard to check if message is a response
+ */
+export declare function isResponseMessage(msg: ProtocolMessage): msg is ResponseMessage;
+/**
+ * Type guard to check if message is an error
+ */
+export declare function isErrorMessage(msg: ProtocolMessage): msg is ErrorMessage;
+/**
+ * Type guard to check if message is an event
+ */
+export declare function isEventMessage(msg: ProtocolMessage): msg is EventMessage;

package/dist/setup-modal/src/types/server.d.ts

@@ -0,0 +1,63 @@
+export type ServerErrorCode = 'server-pending-ext-ready' | 'server-conn-refused' | 'server-conn-timeout' | 'server-not-found' | 'server-network-unreachable' | 'server-service-unavailable' | 'server-unexpected-error' | 'server-in-setup-status' | 'server-in-admin-status';
+export declare const SERVER_PENDING_EXT_READY: ServerErrorCode;
+export declare const SERVER_CONN_REFUSED: ServerErrorCode;
+export declare const SERVER_CONN_TIMEOUT: ServerErrorCode;
+export declare const SERVER_NOT_FOUND: ServerErrorCode;
+export declare const SERVER_NETWORK_UNREACHABLE: ServerErrorCode;
+export declare const SERVER_SERVICE_UNAVAILABLE: ServerErrorCode;
+export declare const SERVER_UNEXPECTED_ERROR: ServerErrorCode;
+export declare const SERVER_IN_SETUP_STATUS: ServerErrorCode;
+export declare const SERVER_IN_ADMIN_STATUS: ServerErrorCode;
+export interface ServerStateReady {
+    /** Current server status */
+    status: 'ready';
+    /** Server version */
+    version: string;
+}
+export interface ServerStateReachable {
+    /** Current server status */
+    status: 'setup' | 'resource-admin';
+    /** Server version */
+    version: string;
+    /** Error details */
+    error: {
+        /** Error message */
+        message: string;
+        /** Error code */
+        code: ServerErrorCode;
+    };
+}
+export interface ServerStatePending {
+    /** Current server status */
+    status: 'pending-extension-ready';
+    /** Error details */
+    error: {
+        /** Error message */
+        message: string;
+        /** Error code */
+        code: ServerErrorCode;
+    };
+}
+export interface ServerStateUnreachable {
+    /** Current server status */
+    status: 'unreachable';
+    /** Error details */
+    error: {
+        /** Error message */
+        message: string;
+        /** Error code */
+        code: ServerErrorCode;
+    };
+}
+export interface ServerStateError {
+    /** Current server status */
+    status: 'error';
+    /** Error details */
+    error: {
+        /** Error message */
+        message: string;
+        /** Error code */
+        code: ServerErrorCode;
+    };
+}
+export type ServerState = ServerStateReady | ServerStateReachable | ServerStatePending | ServerStateUnreachable | ServerStateError;

package/dist/setup-modal/src/types/state.d.ts

@@ -0,0 +1,42 @@
+import { Browser, EnvState, OS } from './platform';
+import { ExtensionState } from './extension';
+import { ServerState } from './server';
+import { LnaServerState, LnaState } from './lna';
+export declare enum SetupStep {
+    PLATFORM_CHECK = "platform-check",
+    SERVER_SETUP = "server-setup",
+    LNA_SETUP = "lna-setup",
+    EXTENSION_SETUP = "extension-setup",
+    COMPLETE = "complete"
+}
+export type SelectedConnection = 'lna' | 'extension' | null;
+export interface UserConfirmations {
+    /** Whether user has confirmed server installation */
+    serverInstall: boolean;
+}
+export declare const DEFAULT_USER_CONFIRMATIONS: UserConfirmations;
+export interface SetupState {
+    /** Extension state details */
+    extension: ExtensionState;
+    /** Server state details (via extension) */
+    server: ServerState;
+    /** LNA connection state */
+    lna: LnaState;
+    /** Server state details (via LNA) */
+    lnaServer: LnaServerState;
+    /** Environment detection */
+    env: EnvState;
+    /** Browser platforms list */
+    browsers: Browser[];
+    /** Operating systems list */
+    os: OS[];
+    /** User confirmations for manual steps */
+    userConfirmations: UserConfirmations;
+    /** User's preferred connection method (null = auto-select based on priority) */
+    selectedConnection: SelectedConnection;
+}
+/**
+ * Default setup state used during initialization before parent sends real state
+ * Represents "loading" state - unknown platform, no extension, no server
+ */
+export declare const DEFAULT_SETUP_STATE: SetupState;

package/dist/setup-modal/src/types/type-guards.d.ts

@@ -0,0 +1,26 @@
+import { ExtensionState, ExtensionStateNotReady, ExtensionStateReady } from './extension';
+import { ServerState, ServerStateError, ServerStatePending, ServerStateReachable, ServerStateReady, ServerStateUnreachable } from './server';
+import { LnaServerState, LnaServerStateError, LnaServerStatePending, LnaServerStateReady, LnaServerStateResourceAdmin, LnaServerStateSetup, LnaState, LnaStateDenied, LnaStateGranted, LnaStatePrompt, LnaStateSkipped, LnaStateUnreachable, LnaStateUnsupported } from './lna';
+import { Browser, NotSupportedBrowser, NotSupportedOS, OS, SupportedBrowser, SupportedOS } from './platform';
+export declare function isExtensionStateReady(ext: ExtensionState): ext is ExtensionStateReady;
+export declare function isExtensionStateNotReady(ext: ExtensionState): ext is ExtensionStateNotReady;
+export declare function isServerStateReady(server: ServerState): server is ServerStateReady;
+export declare function isServerStateReachable(server: ServerState): server is ServerStateReachable;
+export declare function isServerStatePending(server: ServerState): server is ServerStatePending;
+export declare function isServerStateUnreachable(server: ServerState): server is ServerStateUnreachable;
+export declare function isServerStateError(server: ServerState): server is ServerStateError;
+export declare function isLnaStatePrompt(lna: LnaState): lna is LnaStatePrompt;
+export declare function isLnaStateSkipped(lna: LnaState): lna is LnaStateSkipped;
+export declare function isLnaStateGranted(lna: LnaState): lna is LnaStateGranted;
+export declare function isLnaStateUnreachable(lna: LnaState): lna is LnaStateUnreachable;
+export declare function isLnaStateDenied(lna: LnaState): lna is LnaStateDenied;
+export declare function isLnaStateUnsupported(lna: LnaState): lna is LnaStateUnsupported;
+export declare function isLnaServerStatePending(server: LnaServerState): server is LnaServerStatePending;
+export declare function isLnaServerStateReady(server: LnaServerState): server is LnaServerStateReady;
+export declare function isLnaServerStateSetup(server: LnaServerState): server is LnaServerStateSetup;
+export declare function isLnaServerStateResourceAdmin(server: LnaServerState): server is LnaServerStateResourceAdmin;
+export declare function isLnaServerStateError(server: LnaServerState): server is LnaServerStateError;
+export declare function isSupportedBrowser(browser: Browser): browser is SupportedBrowser;
+export declare function isNotSupportedBrowser(browser: Browser): browser is NotSupportedBrowser;
+export declare function isSupportedOS(os: OS): os is SupportedOS;
+export declare function isNotSupportedOS(os: OS): os is NotSupportedOS;

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@bodhiapp/bodhi-js-react-core",
+  "version": "0.0.11",
+  "description": "Core React bindings for Bodhi Browser SDK (dependency injection)",
+  "type": "module",
+  "main": "dist/bodhi-react-core.cjs.js",
+  "module": "dist/bodhi-react-core.esm.js",
+  "exports": {
+    ".": {
+      "types": "./dist/bodhi-react-core.esm.d.ts",
+      "import": "./dist/bodhi-react-core.esm.js",
+      "require": "./dist/bodhi-react-core.cjs.js"
+    },
+    "./api": {
+      "types": "./src/api/index.ts",
+      "import": "./src/api/index.ts",
+      "default": "./src/api/index.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BodhiSearch/bodhi-js.git",
+    "directory": "bodhi-js-sdk/react-core"
+  },
+  "license": "MIT",
+  "author": "BodhiSearch",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "vite build --mode development",
+    "ci:build": "vite build --mode development",
+    "dev:build": "node ../../scripts/build-fast.mjs bodhi-js-sdk/react-core 'npm run build' src package.json vite.config.ts",
+    "build:prod": "vite build --mode production",
+    "lint": "eslint . --ext .js,.jsx,.ts,.tsx && prettier --check .",
+    "lint:fix": "prettier --write . && eslint . --ext .js,.jsx,.ts,.tsx --fix",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@bodhiapp/bodhi-js-core": "0.0.11",
+    "@bodhiapp/ts-client": "0.1.9"
+  },
+  "peerDependencies": {
+    "react": "^18.3.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.23.0",
+    "@types/node": "^20.19.10",
+    "@types/react": "^19.0.0",
+    "@typescript-eslint/eslint-plugin": "8.28.0",
+    "@typescript-eslint/parser": "8.28.0",
+    "eslint": "9.32.0",
+    "eslint-config-prettier": "10.1.8",
+    "globals": "^16.0.0",
+    "prettier": "3.6.2",
+    "rimraf": "^6.0.1",
+    "tslib": "^2.6.2",
+    "typescript": "^5.8.3",
+    "vite": "^7.1.12",
+    "vite-plugin-dts": "^4.5.4"
+  }
+}