@bodhiapp/setup-modal-types 0.0.20 → 0.0.22

package/dist/extension.d.ts

@@ -0,0 +1,24 @@
+export type ExtensionErrorCode = 'ext-not-installed' | 'ext-connection-failed' | 'ext-unsupported-version';
+export declare const EXT_NOT_INSTALLED: ExtensionErrorCode;
+export declare const EXT_CONNECTION_FAILED: ExtensionErrorCode;
+export declare const EXT_UNSUPPORTED_VERSION: ExtensionErrorCode;
+export interface ExtensionStateReady {
+    /** Current extension status */
+    status: 'ready';
+    /** Extension version */
+    version: string;
+    /** Extension ID (always present when ready) */
+    id: string;
+}
+export interface ExtensionStateNotReady {
+    /** Current extension status */
+    status: 'unreachable' | 'not-installed' | 'unsupported';
+    /** Error details */
+    error: {
+        /** Error message */
+        message: string;
+        /** Error code */
+        code: ExtensionErrorCode;
+    };
+}
+export type ExtensionState = ExtensionStateReady | ExtensionStateNotReady;

package/{index.ts → dist/index.d.ts}

@@ -4,81 +4,17 @@
  * This folder contains all domain and protocol types organized by domain.
  * It is designed to be independent and copyable to other packages.
  */
-
-// Platform types
 export type { BrowserType, OSType, EnvState, SupportedBrowser, NotSupportedBrowser, Browser, SupportedOS, NotSupportedOS, OS } from './platform';
-
-// Extension types
 export type { ExtensionErrorCode, ExtensionStateReady, ExtensionStateNotReady, ExtensionState } from './extension';
 export { EXT_NOT_INSTALLED, EXT_CONNECTION_FAILED, EXT_UNSUPPORTED_VERSION } from './extension';
-
-// Server types
 export type { ServerErrorCode, ServerStateReady, ServerStateReachable, ServerStatePending, ServerStateUnreachable, ServerStateError, ServerState } from './server';
-export {
-  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,
-} from './server';
-
-// LNA types
-export type {
-  LnaErrorCode,
-  LnaStatePrompt,
-  LnaStateSkipped,
-  LnaStateGranted,
-  LnaStateUnreachable,
-  LnaStateDenied,
-  LnaStateUnsupported,
-  LnaState,
-  LnaServerStatePending,
-  LnaServerStateReady,
-  LnaServerStateSetup,
-  LnaServerStateResourceAdmin,
-  LnaServerStateError,
-  LnaServerState,
-} from './lna';
+export { 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, } from './server';
+export type { LnaErrorCode, LnaStatePrompt, LnaStateSkipped, LnaStateGranted, LnaStateUnreachable, LnaStateDenied, LnaStateUnsupported, LnaState, LnaServerStatePending, LnaServerStateReady, LnaServerStateSetup, LnaServerStateResourceAdmin, LnaServerStateError, LnaServerState, } from './lna';
 export { LNA_UNREACHABLE, LNA_PERMISSION_DENIED } from './lna';
-
-// State types
 export { SetupStep, DEFAULT_USER_CONFIRMATIONS, DEFAULT_SETUP_STATE } from './state';
 export type { SelectedConnection, UserConfirmations, SetupState } from './state';
-
-// Protocol types
 export type { RequestId, MessageKind, RequestMessage, ResponseMessage, ErrorMessage, EventMessage, ProtocolMessage } from './protocol';
 export { isRequestMessage, isResponseMessage, isErrorMessage, isEventMessage } from './protocol';
-
-// Message types
 export type { MessageTypeRegistry, MessageType, RequestPayload, ResponsePayload, RequestHandlers } from './message-types';
 export { MSG, isMessageType } from './message-types';
-
-// Type guards
-export {
-  isExtensionStateReady,
-  isExtensionStateNotReady,
-  isServerStateReady,
-  isServerStateReachable,
-  isServerStatePending,
-  isServerStateUnreachable,
-  isServerStateError,
-  isLnaStatePrompt,
-  isLnaStateSkipped,
-  isLnaStateGranted,
-  isLnaStateUnreachable,
-  isLnaStateDenied,
-  isLnaStateUnsupported,
-  isLnaServerStatePending,
-  isLnaServerStateReady,
-  isLnaServerStateSetup,
-  isLnaServerStateResourceAdmin,
-  isLnaServerStateError,
-  isSupportedBrowser,
-  isNotSupportedBrowser,
-  isSupportedOS,
-  isNotSupportedOS,
-} from './type-guards';
+export { isExtensionStateReady, isExtensionStateNotReady, isServerStateReady, isServerStateReachable, isServerStatePending, isServerStateUnreachable, isServerStateError, isLnaStatePrompt, isLnaStateSkipped, isLnaStateGranted, isLnaStateUnreachable, isLnaStateDenied, isLnaStateUnsupported, isLnaServerStatePending, isLnaServerStateReady, isLnaServerStateSetup, isLnaServerStateResourceAdmin, isLnaServerStateError, isSupportedBrowser, isNotSupportedBrowser, isSupportedOS, isNotSupportedOS, } from './type-guards';

package/dist/index.js

@@ -0,0 +1,180 @@
+const EXT_NOT_INSTALLED = "ext-not-installed";
+const EXT_CONNECTION_FAILED = "ext-connection-failed";
+const EXT_UNSUPPORTED_VERSION = "ext-unsupported-version";
+const SERVER_PENDING_EXT_READY = "server-pending-ext-ready";
+const SERVER_CONN_REFUSED = "server-conn-refused";
+const SERVER_CONN_TIMEOUT = "server-conn-timeout";
+const SERVER_NOT_FOUND = "server-not-found";
+const SERVER_NETWORK_UNREACHABLE = "server-network-unreachable";
+const SERVER_SERVICE_UNAVAILABLE = "server-service-unavailable";
+const SERVER_UNEXPECTED_ERROR = "server-unexpected-error";
+const SERVER_IN_SETUP_STATUS = "server-in-setup-status";
+const SERVER_IN_ADMIN_STATUS = "server-in-admin-status";
+const LNA_UNREACHABLE = "lna-unreachable";
+const LNA_PERMISSION_DENIED = "lna-permission-denied";
+var SetupStep = /* @__PURE__ */ ((SetupStep2) => {
+  SetupStep2["PLATFORM_CHECK"] = "platform-check";
+  SetupStep2["SERVER_SETUP"] = "server-setup";
+  SetupStep2["LNA_SETUP"] = "lna-setup";
+  SetupStep2["EXTENSION_SETUP"] = "extension-setup";
+  SetupStep2["COMPLETE"] = "complete";
+  return SetupStep2;
+})(SetupStep || {});
+const DEFAULT_USER_CONFIRMATIONS = {
+  serverInstall: false
+};
+const DEFAULT_SETUP_STATE = {
+  extension: { status: "not-installed", error: { message: "Loading...", code: "ext-not-installed" } },
+  server: { status: "pending-extension-ready", error: { message: "Loading...", code: "server-pending-ext-ready" } },
+  lna: { status: "prompt" },
+  lnaServer: { status: "pending-lna-ready" },
+  env: { browser: "unknown", os: "unknown" },
+  browsers: [],
+  os: [],
+  userConfirmations: DEFAULT_USER_CONFIRMATIONS,
+  selectedConnection: null
+};
+function isRequestMessage(msg) {
+  return msg.kind === "request";
+}
+function isResponseMessage(msg) {
+  return msg.kind === "response";
+}
+function isErrorMessage(msg) {
+  return msg.kind === "error";
+}
+function isEventMessage(msg) {
+  return msg.kind === "event";
+}
+const MSG = {
+  // Modal lifecycle
+  MODAL_READY: "modal:ready",
+  MODAL_REFRESH: "modal:refresh",
+  MODAL_CLOSE: "modal:close",
+  MODAL_COMPLETE: "modal:complete",
+  // LNA actions
+  MODAL_LNA_CONNECT: "modal:lna:connect",
+  MODAL_LNA_SKIP: "modal:lna:skip",
+  // Server confirmation
+  MODAL_CONFIRM_SERVER_INSTALL: "modal:confirm-server-install",
+  // Connection selection
+  MODAL_SELECT_CONNECTION: "modal:select-connection",
+  // Parent → Modal events
+  PARENT_STATE_UPDATE: "parent:state-update"
+};
+function isMessageType(msg, type) {
+  return msg.type === type;
+}
+function isExtensionStateReady(ext) {
+  return ext.status === "ready";
+}
+function isExtensionStateNotReady(ext) {
+  return ext.status !== "ready";
+}
+function isServerStateReady(server) {
+  return server.status === "ready";
+}
+function isServerStateReachable(server) {
+  return server.status === "setup" || server.status === "resource-admin";
+}
+function isServerStatePending(server) {
+  return server.status === "pending-extension-ready";
+}
+function isServerStateUnreachable(server) {
+  return server.status === "unreachable";
+}
+function isServerStateError(server) {
+  return server.status === "error";
+}
+function isLnaStatePrompt(lna) {
+  return lna.status === "prompt";
+}
+function isLnaStateSkipped(lna) {
+  return lna.status === "skipped";
+}
+function isLnaStateGranted(lna) {
+  return lna.status === "granted";
+}
+function isLnaStateUnreachable(lna) {
+  return lna.status === "unreachable";
+}
+function isLnaStateDenied(lna) {
+  return lna.status === "denied";
+}
+function isLnaStateUnsupported(lna) {
+  return lna.status === "unsupported";
+}
+function isLnaServerStatePending(server) {
+  return server.status === "pending-lna-ready";
+}
+function isLnaServerStateReady(server) {
+  return server.status === "ready";
+}
+function isLnaServerStateSetup(server) {
+  return server.status === "setup";
+}
+function isLnaServerStateResourceAdmin(server) {
+  return server.status === "resource-admin";
+}
+function isLnaServerStateError(server) {
+  return server.status === "error";
+}
+function isSupportedBrowser(browser) {
+  return browser.status === "supported";
+}
+function isNotSupportedBrowser(browser) {
+  return browser.status === "not-supported";
+}
+function isSupportedOS(os) {
+  return os.status === "supported";
+}
+function isNotSupportedOS(os) {
+  return os.status === "not-supported";
+}
+export {
+  DEFAULT_SETUP_STATE,
+  DEFAULT_USER_CONFIRMATIONS,
+  EXT_CONNECTION_FAILED,
+  EXT_NOT_INSTALLED,
+  EXT_UNSUPPORTED_VERSION,
+  LNA_PERMISSION_DENIED,
+  LNA_UNREACHABLE,
+  MSG,
+  SERVER_CONN_REFUSED,
+  SERVER_CONN_TIMEOUT,
+  SERVER_IN_ADMIN_STATUS,
+  SERVER_IN_SETUP_STATUS,
+  SERVER_NETWORK_UNREACHABLE,
+  SERVER_NOT_FOUND,
+  SERVER_PENDING_EXT_READY,
+  SERVER_SERVICE_UNAVAILABLE,
+  SERVER_UNEXPECTED_ERROR,
+  SetupStep,
+  isErrorMessage,
+  isEventMessage,
+  isExtensionStateNotReady,
+  isExtensionStateReady,
+  isLnaServerStateError,
+  isLnaServerStatePending,
+  isLnaServerStateReady,
+  isLnaServerStateResourceAdmin,
+  isLnaServerStateSetup,
+  isLnaStateDenied,
+  isLnaStateGranted,
+  isLnaStatePrompt,
+  isLnaStateSkipped,
+  isLnaStateUnreachable,
+  isLnaStateUnsupported,
+  isMessageType,
+  isNotSupportedBrowser,
+  isNotSupportedOS,
+  isRequestMessage,
+  isResponseMessage,
+  isServerStateError,
+  isServerStatePending,
+  isServerStateReachable,
+  isServerStateReady,
+  isServerStateUnreachable,
+  isSupportedBrowser,
+  isSupportedOS
+};

package/dist/lna.d.ts

@@ -0,0 +1,56 @@
+export type LnaErrorCode = 'lna-unreachable' | 'lna-permission-denied';
+export declare const LNA_UNREACHABLE: LnaErrorCode;
+export declare const LNA_PERMISSION_DENIED: LnaErrorCode;
+export interface LnaStatePrompt {
+    status: 'prompt';
+    serverUrl?: string;
+}
+export interface LnaStateSkipped {
+    status: 'skipped';
+    serverUrl?: string;
+}
+export interface LnaStateGranted {
+    status: 'granted';
+    serverUrl: string;
+}
+export interface LnaStateUnreachable {
+    status: 'unreachable';
+    serverUrl: string;
+    error: {
+        message: string;
+        code: LnaErrorCode;
+    };
+}
+export interface LnaStateDenied {
+    status: 'denied';
+    error: {
+        message: string;
+        code: LnaErrorCode;
+    };
+}
+export interface LnaStateUnsupported {
+    status: 'unsupported';
+}
+export type LnaState = LnaStatePrompt | LnaStateSkipped | LnaStateGranted | LnaStateUnreachable | LnaStateDenied | LnaStateUnsupported;
+export interface LnaServerStatePending {
+    status: 'pending-lna-ready';
+}
+export interface LnaServerStateReady {
+    status: 'ready';
+    version: string;
+}
+export interface LnaServerStateSetup {
+    status: 'setup';
+    version: string;
+}
+export interface LnaServerStateResourceAdmin {
+    status: 'resource-admin';
+    version: string;
+}
+export interface LnaServerStateError {
+    status: 'error';
+    error: {
+        message: string;
+    };
+}
+export type LnaServerState = LnaServerStatePending | LnaServerStateReady | LnaServerStateSetup | LnaServerStateResourceAdmin | LnaServerStateError;

package/dist/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/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/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/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;