@orbitconnect/react 0.1.0

package/dist/meeting/MeetingContext.d.ts

@@ -0,0 +1,19 @@
+import type { ActiveMeeting } from '../hooks/useMeeting';
+import type { ReactionEvent } from '../components/meeting/ReactionBurst';
+export interface MeetingContextValue {
+    meeting: ActiveMeeting | null;
+    localStream: MediaStream | null;
+    localDisplayStream: MediaStream | null;
+    reactionEvents: ReactionEvent[];
+    joinMeeting: (meetingId: string, title: string) => Promise<void>;
+    leaveMeeting: () => Promise<void>;
+    muteSelf: (muted: boolean) => void;
+    toggleCamera: (off: boolean) => void;
+    startScreenShare: () => Promise<void>;
+    stopScreenShare: () => Promise<void>;
+    raiseHand: () => void;
+    lowerHand: () => void;
+    sendReaction: (emoji: string) => void;
+}
+export declare const MeetingContext: import("react").Context<MeetingContextValue | null>;
+export declare function useMeetingContext(): MeetingContextValue;

package/dist/meeting/MeetingProvider.d.ts

@@ -0,0 +1,4 @@
+import { type ReactNode } from 'react';
+export declare function MeetingProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/meeting/index.d.ts

@@ -0,0 +1,3 @@
+export { MeetingProvider } from './MeetingProvider';
+export { MeetingContext, useMeetingContext } from './MeetingContext';
+export type { MeetingContextValue } from './MeetingContext';

package/dist/socket/OrbitListenerProvider.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from 'react';
+export interface OrbitListenerProviderProps {
+    clientId: string;
+    userToken: string;
+    /** Optional REST base URL — used to derive the WS URL when provided */
+    baseUrl?: string;
+    maxRetries?: number;
+    retryBaseMs?: number;
+    heartbeatMs?: number;
+    /** Called when the server closes the connection with code 4001 (token expired). Should return a fresh token. */
+    onTokenExpired?: () => Promise<string>;
+    children: ReactNode;
+}
+export declare function OrbitListenerProvider({ clientId, userToken, baseUrl, maxRetries, retryBaseMs, heartbeatMs, onTokenExpired, children, }: OrbitListenerProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/socket/OrbitSocket.d.ts

@@ -0,0 +1,97 @@
+import type { OrbitSocketEvents, OrbitEventType } from './events';
+export type EventHandler<T> = (payload: T) => void;
+export interface OrbitSocketOptions {
+    /** Resolved WebSocket endpoint — set internally by the SDK, never by the consumer */
+    readonly wsUrl: string;
+    /** Publishable client ID (pk_live_... / pk_test_...) */
+    readonly clientId: string;
+    /** Short-lived user token from your server SDK */
+    token: string;
+    /** Reconnect attempts before giving up. Default: 5 */
+    maxRetries?: number;
+    /** Base delay in ms for exponential backoff. Default: 1000 */
+    retryBaseMs?: number;
+    /** Heartbeat interval in ms. Default: 25000 */
+    heartbeatMs?: number;
+    /** Called when the server closes the connection with code 4001 (token expired). Should return a fresh token. */
+    onTokenExpired?: () => Promise<string>;
+}
+export type SocketStatus = 'connecting' | 'connected' | 'reconnecting' | 'disconnected';
+type StatusListener = (status: SocketStatus) => void;
+/**
+ * Typed WebSocket client for OrbitConnect.
+ *
+ * - Auto-reconnect with exponential backoff
+ * - Heartbeat ping/pong keepalive
+ * - Typed event subscriptions matching OrbitSocketEvents
+ */
+export declare class OrbitSocket {
+    private ws;
+    private handlers;
+    private statusListeners;
+    private retries;
+    private retryTimer;
+    private heartbeatTimer;
+    private destroyed;
+    private readonly maxRetries;
+    private readonly retryBaseMs;
+    private readonly heartbeatMs;
+    status: SocketStatus;
+    readonly opts: OrbitSocketOptions;
+    constructor(opts: OrbitSocketOptions);
+    connect(): void;
+    disconnect(): void;
+    /** Subscribe to a typed server event */
+    on<K extends OrbitEventType>(event: K, handler: EventHandler<OrbitSocketEvents[K]>): () => void;
+    off<K extends OrbitEventType>(event: K, handler: EventHandler<OrbitSocketEvents[K]>): void;
+    /** Listen to connection status changes */
+    onStatus(listener: StatusListener): () => void;
+    /** Subscribe to a context (conversation / call / meeting) */
+    subscribeContext(contextId: string): void;
+    unsubscribeContext(contextId: string): void;
+    /** Notify server you are typing in a conversation */
+    sendTyping(conversationId: string): void;
+    sendStoppedTyping(conversationId: string): void;
+    /** Acknowledge message delivery */
+    sendAck(messageId: string): void;
+    /** Mark message as read */
+    sendRead(messageId: string): void;
+    /** Update presence status */
+    sendPresence(status: 'online' | 'away' | 'offline'): void;
+    /** Send WebRTC offer SDP via WS (fast path, also persisted via REST in useWebRTC) */
+    sendOffer(callId: string, sdp: string): void;
+    /** Send WebRTC answer SDP via WS */
+    sendAnswer(callId: string, sdp: string): void;
+    /** Trickle ICE candidate */
+    sendIceCandidate(callId: string, candidate: string, sdpMid?: string | null, sdpMLineIndex?: number | null): void;
+    /** Broadcast mute state to remote party */
+    sendCallMute(callId: string, muted: boolean): void;
+    /** Raise hand in a meeting */
+    sendRaiseHand(meetingId: string): void;
+    sendLowerHand(meetingId: string): void;
+    /** Send emoji reaction in a meeting */
+    sendReaction(meetingId: string, emoji: string): void;
+    /** Report active speaker state (from client-side VAD) */
+    sendActiveSpeaker(meetingId: string, speaking: boolean): void;
+    /** Toggle screen share via WS fast path */
+    sendScreenShare(meetingId: string, sharing: boolean): void;
+    /** Self-mute in a meeting */
+    sendMeetingMute(meetingId: string, muted: boolean): void;
+    /** Send WebRTC offer to a specific peer in a meeting */
+    sendMeetingOffer(meetingId: string, targetUserId: string, sdp: string): void;
+    /** Send WebRTC answer to a specific peer in a meeting */
+    sendMeetingAnswer(meetingId: string, targetUserId: string, sdp: string): void;
+    /** Send ICE candidate to a specific peer in a meeting */
+    sendMeetingIceCandidate(meetingId: string, targetUserId: string, candidate: string, sdpMid?: string | null, sdpMLineIndex?: number | null): void;
+    /** Put a call on hold or resume it */
+    sendHold(callId: string, onHold: boolean): void;
+    private contextSubscriptions;
+    private openSocket;
+    private dispatch;
+    private send;
+    private scheduleReconnect;
+    private startHeartbeat;
+    private clearTimers;
+    private setStatus;
+}
+export {};

package/dist/socket/config.d.ts

@@ -0,0 +1,10 @@
+/**
+ * SDK-internal endpoint resolution.
+ *
+ * clientId format:  pk_live_<...>  →  wss://api.orbitconnect.cloud/ws
+ *                   pk_test_<...>  →  wss://sandbox.orbitconnect.cloud/ws
+ *
+ * In development, set VITE_ORBIT_WS_URL to override:
+ *   VITE_ORBIT_WS_URL=ws://localhost:3000/ws
+ */
+export declare function resolveWsUrl(clientId: string): string;

package/dist/socket/context.d.ts

@@ -0,0 +1,10 @@
+import type { OrbitSocket } from './OrbitSocket';
+import type { SocketStatus } from './OrbitSocket';
+export interface OrbitListenerContextValue {
+    socket: OrbitSocket;
+    status: SocketStatus;
+    subscribeContext: (contextId: string) => void;
+    unsubscribeContext: (contextId: string) => void;
+}
+export declare const OrbitListenerContext: import("react").Context<OrbitListenerContextValue | null>;
+export declare function useOrbitListener(): OrbitListenerContextValue;

package/dist/socket/events.d.ts

@@ -0,0 +1,283 @@
+/**
+ * All server → client WebSocket event types emitted by OrbitConnect backend.
+ * Protocol: { type: string, payload: Record<string, unknown> }
+ */
+export interface ConnectedPayload {
+    app_user_id: string;
+    display_name: string;
+}
+export interface SubscribedPayload {
+    context_id: string;
+}
+export interface UnsubscribedPayload {
+    context_id: string;
+}
+export interface PongPayload {
+    ts: number;
+}
+export interface MessageNewPayload {
+    conversation_id: string;
+    message: {
+        id: string;
+        sender_id: string;
+        type: 'text' | 'media' | 'system';
+        content: string | null;
+        metadata: Record<string, unknown>;
+        sequence_number: number;
+        created_at: string;
+        updated_at: string;
+    };
+}
+export interface MessageDeliveredPayload {
+    message_id: string;
+    app_user_id: string;
+}
+export interface MessageReadPayload {
+    message_id: string;
+    app_user_id: string;
+}
+export interface ConversationUpdatedPayload {
+    conversation_id: string;
+}
+export interface MessageReactionPayload {
+    message_id: string;
+    app_user_id: string;
+    reaction_type: string;
+    action: 'added' | 'removed';
+}
+export interface MessageRecalledPayload {
+    message_id: string;
+    conversation_id: string;
+}
+export interface MessageEditedPayload {
+    message_id: string;
+    conversation_id: string;
+    content: string;
+}
+export interface MessagePinnedPayload {
+    message_id: string;
+    conversation_id: string;
+    pinned_by: string;
+}
+export interface MessageUnpinnedPayload {
+    message_id: string;
+    conversation_id: string;
+}
+export interface CallIncomingPayload {
+    call_id: string;
+    caller_id: string;
+    caller_name?: string;
+    caller_avatar?: string | null;
+    type: 'voice' | 'video';
+}
+export interface CallRingingPayload {
+    call_id: string;
+    callee_id?: string;
+    callee_name?: string;
+    callee_avatar?: string | null;
+}
+export interface CallAcceptedPayload {
+    call_id: string;
+    callee_id: string;
+}
+export interface CallRejectedPayload {
+    call_id: string;
+    callee_id: string;
+}
+export interface CallEndedPayload {
+    call_id: string;
+    ended_by: string;
+}
+export interface WebRtcOfferPayload {
+    call_id: string;
+    sdp: string;
+}
+export interface WebRtcAnswerPayload {
+    call_id: string;
+    sdp: string;
+}
+export interface WebRtcIceCandidatePayload {
+    call_id: string;
+    candidate: string;
+    sdpMid?: string;
+    sdpMLineIndex?: number;
+}
+export interface MeetingStartedPayload {
+    meeting_id: string;
+    started_at: string;
+}
+export interface MeetingEndedPayload {
+    meeting_id: string;
+    ended_at: string;
+    ended_by: string;
+}
+export interface ParticipantJoinedPayload {
+    meeting_id: string;
+    app_user_id: string;
+    display_name?: string | null;
+}
+export interface ParticipantLeftPayload {
+    meeting_id: string;
+    app_user_id: string;
+    kicked?: boolean;
+    kicked_by?: string;
+}
+export interface ParticipantMutedPayload {
+    meeting_id: string;
+    app_user_id: string;
+    muted_by: string;
+}
+export interface ParticipantUnmutedPayload {
+    meeting_id: string;
+    app_user_id: string;
+    muted_by: string;
+}
+export interface ScreenShareStartedPayload {
+    meeting_id: string;
+    app_user_id: string;
+}
+export interface ScreenShareStoppedPayload {
+    meeting_id: string;
+    app_user_id: string;
+}
+export interface SessionStartedPayload {
+    session_id: string;
+    type: 'chat_session' | 'call_session' | 'meeting_session';
+    context_id?: string;
+}
+export interface SessionEndedPayload {
+    session_id: string;
+}
+export interface SessionTransitionedPayload {
+    session_id: string;
+    transition_type: string;
+    context_id?: string;
+}
+export interface ChatTypingPayload {
+    conversation_id: string;
+    app_user_id: string;
+    display_name: string;
+}
+export interface ChatStoppedTypingPayload {
+    conversation_id: string;
+    app_user_id: string;
+}
+export interface PresenceChangedPayload {
+    app_user_id: string;
+    display_name: string;
+    status: 'online' | 'away' | 'offline';
+}
+export interface CallMuteChangedPayload {
+    call_id: string;
+    app_user_id: string;
+    muted: boolean;
+}
+export interface CallHoldChangedPayload {
+    call_id: string;
+    app_user_id: string;
+    on_hold: boolean;
+}
+export interface MeetingHandRaisedPayload {
+    meeting_id: string;
+    app_user_id: string;
+    display_name: string;
+}
+export interface MeetingHandLoweredPayload {
+    meeting_id: string;
+    app_user_id: string;
+}
+export interface MeetingReactionPayload {
+    meeting_id: string;
+    app_user_id: string;
+    display_name: string;
+    emoji: string;
+}
+export interface MeetingActiveSpeakerPayload {
+    meeting_id: string;
+    app_user_id: string;
+    speaking: boolean;
+}
+export interface MeetingOfferPayload {
+    meeting_id: string;
+    from_user_id: string;
+    sdp: string;
+}
+export interface MeetingAnswerPayload {
+    meeting_id: string;
+    from_user_id: string;
+    sdp: string;
+}
+export interface MeetingIceCandidatePayload {
+    meeting_id: string;
+    from_user_id: string;
+    candidate: string;
+    sdpMid?: string | null;
+    sdpMLineIndex?: number | null;
+}
+export interface AuthTokenExpiredPayload {
+    code: 4001;
+}
+export interface MediaReadyPayload {
+    media_id: string;
+    status: 'ready' | 'failed';
+    file_url: string;
+    mime_type: string;
+}
+export interface NotificationReceivedPayload {
+    /** Notification type, e.g. "alert", "info", "warning" */
+    type: string;
+    /** Arbitrary data sent by the server */
+    payload: Record<string, unknown>;
+    /** ISO timestamp of when the notification was sent */
+    timestamp: string;
+}
+export interface OrbitSocketEvents {
+    'auth:token_expired': AuthTokenExpiredPayload;
+    'media:ready': MediaReadyPayload;
+    'notification:received': NotificationReceivedPayload;
+    'connected': ConnectedPayload;
+    'subscribed': SubscribedPayload;
+    'unsubscribed': UnsubscribedPayload;
+    'pong': PongPayload;
+    'message:new': MessageNewPayload;
+    'message:delivered': MessageDeliveredPayload;
+    'message:read': MessageReadPayload;
+    'message:reaction': MessageReactionPayload;
+    'message:recalled': MessageRecalledPayload;
+    'message:edited': MessageEditedPayload;
+    'message:pinned': MessagePinnedPayload;
+    'message:unpinned': MessageUnpinnedPayload;
+    'conversation:updated': ConversationUpdatedPayload;
+    'chat:typing': ChatTypingPayload;
+    'chat:stopped_typing': ChatStoppedTypingPayload;
+    'presence:changed': PresenceChangedPayload;
+    'call:incoming': CallIncomingPayload;
+    'call:ringing': CallRingingPayload;
+    'call:accepted': CallAcceptedPayload;
+    'call:rejected': CallRejectedPayload;
+    'call:ended': CallEndedPayload;
+    'call:mute_changed': CallMuteChangedPayload;
+    'call:hold_changed': CallHoldChangedPayload;
+    'webrtc:offer': WebRtcOfferPayload;
+    'webrtc:answer': WebRtcAnswerPayload;
+    'webrtc:ice_candidate': WebRtcIceCandidatePayload;
+    'meeting:started': MeetingStartedPayload;
+    'meeting:ended': MeetingEndedPayload;
+    'participant:joined': ParticipantJoinedPayload;
+    'participant:left': ParticipantLeftPayload;
+    'participant:muted': ParticipantMutedPayload;
+    'participant:unmuted': ParticipantUnmutedPayload;
+    'screen_share:started': ScreenShareStartedPayload;
+    'screen_share:stopped': ScreenShareStoppedPayload;
+    'meeting:hand_raised': MeetingHandRaisedPayload;
+    'meeting:hand_lowered': MeetingHandLoweredPayload;
+    'meeting:reaction': MeetingReactionPayload;
+    'meeting:active_speaker': MeetingActiveSpeakerPayload;
+    'meeting:offer': MeetingOfferPayload;
+    'meeting:answer': MeetingAnswerPayload;
+    'meeting:ice_candidate': MeetingIceCandidatePayload;
+    'session:started': SessionStartedPayload;
+    'session:ended': SessionEndedPayload;
+    'session:transitioned': SessionTransitionedPayload;
+}
+export type OrbitEventType = keyof OrbitSocketEvents;

package/dist/socket/index.d.ts

@@ -0,0 +1,8 @@
+export { OrbitListenerProvider } from './OrbitListenerProvider';
+export type { OrbitListenerProviderProps } from './OrbitListenerProvider';
+export { useOrbitListener } from './context';
+export type { OrbitListenerContextValue } from './context';
+export { useOrbitEvent } from './useOrbitEvent';
+export { OrbitSocket } from './OrbitSocket';
+export type { OrbitSocketOptions, SocketStatus } from './OrbitSocket';
+export type { OrbitSocketEvents, OrbitEventType } from './events';

package/dist/socket/useOrbitEvent.d.ts

@@ -0,0 +1,8 @@
+import type { OrbitEventType, OrbitSocketEvents } from './events';
+/**
+ * Subscribe to a typed OrbitConnect socket event.
+ *
+ * @example
+ * useOrbitEvent('message:new', (p) => addMessage(p.message))
+ */
+export declare function useOrbitEvent<K extends OrbitEventType>(event: K, handler: (payload: OrbitSocketEvents[K]) => void): void;

package/dist/theme/ThemeProvider.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from 'react';
+import type { OrbitTheme, PartialTheme } from './types';
+interface ThemeContextValue {
+    theme: OrbitTheme;
+}
+export declare function useTheme(): ThemeContextValue;
+interface ThemeProviderProps {
+    /** Partial theme overrides — merged on top of the default dark theme */
+    theme?: PartialTheme;
+    /** Base theme to extend. Defaults to 'dark'. */
+    baseTheme?: OrbitTheme;
+    children: ReactNode;
+    /** Optional className for the wrapper div */
+    className?: string;
+}
+export declare function ThemeProvider({ theme: overrides, baseTheme, children, className, }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/theme/defaults.d.ts

@@ -0,0 +1,3 @@
+import type { OrbitTheme } from './types';
+export declare const darkTheme: OrbitTheme;
+export declare const lightTheme: OrbitTheme;

package/dist/theme/index.d.ts

@@ -0,0 +1,3 @@
+export { ThemeProvider, useTheme } from './ThemeProvider';
+export { darkTheme, lightTheme } from './defaults';
+export type { OrbitTheme, PartialTheme } from './types';

package/dist/theme/types.d.ts

@@ -0,0 +1,85 @@
+export interface OrbitTheme {
+    background: string;
+    foreground: string;
+    border: string;
+    input: string;
+    primary: string;
+    primaryForeground: string;
+    secondary: string;
+    secondaryForeground: string;
+    muted: string;
+    mutedForeground: string;
+    card: string;
+    cardForeground: string;
+    sidebar: string;
+    sidebarForeground: string;
+    sidebarPrimary: string;
+    sidebarPrimaryForeground: string;
+    success: string;
+    successForeground: string;
+    accent: string;
+    accentForeground: string;
+    destructive: string;
+    destructiveForeground: string;
+    warning: string;
+    warningForeground: string;
+    /** Outgoing bubble background */
+    bubbleSender: string;
+    /** Outgoing bubble text */
+    bubbleSenderForeground: string;
+    /** Incoming bubble background */
+    bubbleReceiver: string;
+    /** Incoming bubble text */
+    bubbleReceiverForeground: string;
+    /** Single check — message sent to server */
+    iconSent: string;
+    /** Double check (grey) — delivered to recipient device */
+    iconDelivered: string;
+    /** Double check (colored) — read by recipient */
+    iconRead: string;
+    messageMeta: string;
+    replyBorder: string;
+    replySenderForeground: string;
+    /** Reply preview bg inside outgoing bubble */
+    replyBgSender: string;
+    /** Reply preview bg inside incoming bubble */
+    replyBgReceiver: string;
+    replyPreviewForeground: string;
+    reactionBg: string;
+    reactionBorder: string;
+    reactionForeground: string;
+    /** Own reaction pill — highlighted state */
+    reactionOwnBg: string;
+    reactionOwnBorder: string;
+    typingDot: string;
+    audioSenderBg: string;
+    audioReceiverBg: string;
+    /** Play button bg inside incoming audio bubble */
+    audioPlayBtnBg: string;
+    audioPlayBtnForeground: string;
+    /** Unplayed waveform bar */
+    waveBarDefault: string;
+    /** Played waveform bar inside incoming bubble */
+    waveBarPlayedReceiver: string;
+    /** Played waveform bar inside outgoing bubble */
+    waveBarPlayedSender: string;
+    audioDuration: string;
+    fileIconBgReceiver: string;
+    fileIconColorReceiver: string;
+    fileIconBgSender: string;
+    fileIconColorSender: string;
+    fileSizeForeground: string;
+    fileDownloadIcon: string;
+    composerBg: string;
+    composerInputBg: string;
+    composerInputBorder: string;
+    composerInputForeground: string;
+    composerPlaceholder: string;
+    composerIconColor: string;
+    radiusSm: string;
+    radiusMd: string;
+    radiusLg: string;
+    radiusXl: string;
+    fontBody: string;
+}
+export type PartialTheme = Partial<OrbitTheme>;

package/dist/widgets/Chat.d.ts

@@ -0,0 +1,13 @@
+import type { ChatHeaderInfo } from '../components/chat/ChatBox';
+export interface ChatProps {
+    /** Open directly to a specific conversation */
+    conversationId?: string;
+    onCallRequest?: (userId: string, type: 'voice' | 'video') => void;
+    /** Replace the default header identity section with a custom component */
+    renderHeader?: (info: ChatHeaderInfo) => React.ReactNode;
+    /** Rendered at the top of the message list when a conversation is open */
+    chatBanner?: React.ReactNode;
+    /** Default quick messages seeded into the picker if the user has none saved */
+    defaultQuickMessages?: import('../components/chat/QuickMessages').QuickMessage[];
+}
+export declare function Chat({ conversationId: initialConvId, onCallRequest, renderHeader, chatBanner, defaultQuickMessages }: ChatProps): import("react/jsx-runtime").JSX.Element;

package/dist/widgets/MeetingWidget.d.ts

@@ -0,0 +1,6 @@
+export interface MeetingWidgetProps {
+    meetingId: string;
+    title?: string;
+    onEnd?: () => void;
+}
+export declare function MeetingWidget({ meetingId, title, onEnd }: MeetingWidgetProps): import("react/jsx-runtime").JSX.Element;

package/dist/widgets/VideoCall.d.ts

@@ -0,0 +1 @@
+export declare function VideoCall(): import("react/jsx-runtime").JSX.Element | null;

package/dist/widgets/index.d.ts

@@ -0,0 +1,6 @@
+export { Chat } from './Chat';
+export type { ChatProps } from './Chat';
+export type { ChatHeaderInfo } from '../components/chat/ChatBox';
+export { VideoCall } from './VideoCall';
+export { MeetingWidget } from './MeetingWidget';
+export type { MeetingWidgetProps } from './MeetingWidget';