sabha-meetings-react 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -1,2 +1,429 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
 
-export { };
+type SabhaTokens = {
+    /** Optional bearer token (Postman-style). Live API primarily uses `vm_session` cookie. */
+    accessToken?: string;
+    refreshToken?: string;
+    /** Session cookie value when running outside the browser (Node / RN). */
+    sessionCookie?: string;
+};
+type SabhaConfig = {
+    /** Sabha API base URL */
+    baseUrl?: string;
+    /**
+     * Origin for auth CORS allow-list (server-side / RN).
+     * Browsers set Origin automatically; still useful for documentation.
+     */
+    origin?: string;
+    /** Optional bearer access token */
+    accessToken?: string;
+    refreshToken?: string;
+    /** Persist/reuse `vm_session` outside the browser */
+    sessionCookie?: string;
+    /** Send cookies (`credentials: "include"`). Default true. */
+    withCredentials?: boolean;
+    socketPath?: string;
+    socketEvents?: Partial<SabhaSocketEvents>;
+    /**
+     * Meeting media / capture policy applied when connecting.
+     * Defaults enable mic+cam and block screenshots/recordings where possible.
+     */
+    mediaPolicy?: Partial<MediaPolicy>;
+};
+declare const DEFAULT_BASE_URL = "https://sabha-api.sthanave.com";
+type SabhaSocketEvents = {
+    join: string;
+    leave: string;
+    participantJoined: string;
+    participantLeft: string;
+    meetingEnded: string;
+    error: string;
+    mediaState: string;
+};
+type SabhaOrg = {
+    id: string;
+    name: string;
+    suspended: boolean;
+};
+/** Shape returned by POST /api/auth/login and GET /api/auth/me */
+type AuthUser = {
+    ok?: boolean;
+    userId: string;
+    username: string;
+    email: string;
+    about?: string;
+    photo?: string;
+    lat?: number | null;
+    lng?: number | null;
+    termsAccepted?: boolean;
+    role?: string;
+    jobTitle?: string;
+    permissions?: string[];
+    platformRole?: string | null;
+    platformAccess?: boolean;
+    org?: SabhaOrg | null;
+    pendingApproval?: unknown;
+    /** Present when API returns JWT-style auth */
+    token?: string;
+    refreshToken?: string;
+    [key: string]: unknown;
+};
+type LoginInput = {
+    email: string;
+    password: string;
+};
+type RegisterInput = {
+    email: string;
+    password: string;
+    username: string;
+    acceptTerms: boolean;
+};
+type VerifyEmailInput = {
+    email: string;
+    code: string;
+};
+type AuthSession = {
+    user: AuthUser;
+    accessToken?: string;
+    refreshToken?: string;
+    sessionCookie?: string;
+};
+type MeetingOrganizer = {
+    id: string;
+    username: string;
+    photo?: string;
+    online?: boolean;
+    lastActive?: string;
+};
+type MeetingInvitee = {
+    id: string;
+    username?: string;
+    photo?: string;
+    [key: string]: unknown;
+};
+/** Shape returned under `meeting` / `meetings[]` from /api/meetings */
+type Meeting = {
+    id: string;
+    title: string;
+    notes?: string;
+    /** Join code, e.g. `rxv-scpd-ppe` */
+    code?: string;
+    startAt: string;
+    durationMin: number;
+    timeZone?: string;
+    groupId?: string;
+    owner?: boolean;
+    canEdit?: boolean;
+    canCancel?: boolean;
+    organizer?: MeetingOrganizer;
+    invitees?: MeetingInvitee[];
+    inviteeIds?: string[];
+    [key: string]: unknown;
+};
+type CreateMeetingInput = {
+    title: string;
+    startAt?: string;
+    durationMin?: number;
+    timeZone?: string;
+    inviteeIds?: string[];
+    notes?: string;
+    groupId?: string;
+};
+type UpdateMeetingInput = {
+    title?: string;
+    startAt?: string;
+    durationMin?: number;
+    timeZone?: string;
+    inviteeIds?: string[];
+    notes?: string;
+    [key: string]: unknown;
+};
+type MeetingConnectionState = "disconnected" | "connecting" | "connected" | "joined" | "error";
+type MeetingParticipant = {
+    id: string;
+    displayName?: string;
+    username?: string;
+    audioEnabled?: boolean;
+    videoEnabled?: boolean;
+    screenSharing?: boolean;
+    [key: string]: unknown;
+};
+type MediaTrackKind = "audio" | "video" | "screen";
+type LocalMediaState = {
+    audioEnabled: boolean;
+    videoEnabled: boolean;
+    screenSharing: boolean;
+    screenOff: boolean;
+};
+type MediaPolicy = {
+    /** Start with microphone enabled */
+    audio: boolean;
+    /** Start with camera enabled */
+    video: boolean;
+    /** Allow screen sharing */
+    allowScreenShare: boolean;
+    /** Soft “screen off” — stop publishing camera/screen locally */
+    screenOff: boolean;
+    /** Block screenshots / screen recording where the platform allows */
+    blockScreenshots: boolean;
+    /** Block OS / in-app screen recording where the platform allows */
+    blockScreenRecording: boolean;
+};
+declare const DEFAULT_MEDIA_POLICY: MediaPolicy;
+type MeetingRoomEventMap = {
+    state: MeetingConnectionState;
+    participantJoined: MeetingParticipant;
+    participantLeft: {
+        id: string;
+    };
+    meetingEnded: {
+        meetingId: string;
+        reason?: string;
+    };
+    mediaState: LocalMediaState;
+    captureAttempt: {
+        type: "screenshot" | "recording" | "visibility";
+        at: string;
+    };
+    error: Error;
+    raw: {
+        event: string;
+        payload: unknown;
+    };
+};
+
+type MediaListener = (state: LocalMediaState) => void;
+/**
+ * Local A/V + screen-share controller for web meetings.
+ * Publishes MediaStreams the host app can attach to <video>/<audio> elements.
+ */
+declare class MediaController {
+    private policy;
+    private micStream;
+    private camStream;
+    private screenStream;
+    private state;
+    private readonly listeners;
+    constructor(policy: MediaPolicy);
+    getMediaState(): LocalMediaState;
+    getMicrophoneStream(): MediaStream | null;
+    getCameraStream(): MediaStream | null;
+    getScreenStream(): MediaStream | null;
+    /** Combined local A/V tracks for attaching to a peer connection / video element. */
+    getLocalStream(): MediaStream;
+    onChange(listener: MediaListener): () => void;
+    start(policy?: Partial<MediaPolicy>): Promise<LocalMediaState>;
+    setAudioEnabled(enabled: boolean): Promise<LocalMediaState>;
+    setVideoEnabled(enabled: boolean): Promise<LocalMediaState>;
+    setScreenOff(off: boolean): Promise<LocalMediaState>;
+    startScreenShare(): Promise<LocalMediaState>;
+    stopScreenShare(): Promise<LocalMediaState>;
+    toggleAudio(): Promise<LocalMediaState>;
+    toggleVideo(): Promise<LocalMediaState>;
+    stopAll(): void;
+    private publish;
+    private ensureMediaDevices;
+}
+
+type CaptureAttemptType = "screenshot" | "recording" | "visibility";
+type CaptureListener = (event: {
+    type: CaptureAttemptType;
+    at: string;
+}) => void;
+/**
+ * Best-effort web protections against screenshots / screen recording.
+ * Browsers cannot fully block OS-level capture; this layer deters casual capture
+ * and notifies the host app so it can blank the UI or end the meeting.
+ */
+declare class ContentProtection {
+    private policy;
+    private enabled;
+    private readonly listeners;
+    private cleanups;
+    private styleEl;
+    constructor(policy: Pick<MediaPolicy, "blockScreenshots" | "blockScreenRecording">);
+    onCaptureAttempt(listener: CaptureListener): () => void;
+    setPolicy(policy: Pick<MediaPolicy, "blockScreenshots" | "blockScreenRecording">): void;
+    enable(): void;
+    disable(): void;
+    private injectStyles;
+    private bindGuards;
+    private obscureBriefly;
+    private emit;
+}
+
+type Listener<T> = (payload: T) => void;
+type MeetingConnectionOptions = {
+    baseUrl: string;
+    meetingId: string;
+    accessToken?: string;
+    sessionCookie?: string;
+    withCredentials?: boolean;
+    socketPath?: string;
+    events?: Partial<SabhaSocketEvents>;
+    mediaPolicy?: Partial<MediaPolicy>;
+};
+declare class MeetingConnection {
+    private readonly options;
+    private socket;
+    private state;
+    private readonly events;
+    private readonly mediaPolicy;
+    readonly media: MediaController;
+    readonly protection: ContentProtection;
+    private readonly listeners;
+    private mediaUnsub;
+    private captureUnsub;
+    constructor(options: MeetingConnectionOptions);
+    get meetingId(): string;
+    get connectionState(): MeetingConnectionState;
+    getMediaState(): LocalMediaState;
+    on<K extends keyof MeetingRoomEventMap>(event: K, listener: Listener<MeetingRoomEventMap[K]>): () => void;
+    connect(): Promise<void>;
+    setAudioEnabled(enabled: boolean): Promise<LocalMediaState>;
+    setVideoEnabled(enabled: boolean): Promise<LocalMediaState>;
+    setScreenOff(off: boolean): Promise<LocalMediaState>;
+    startScreenShare(): Promise<LocalMediaState>;
+    stopScreenShare(): Promise<LocalMediaState>;
+    leave(): Promise<void>;
+    disconnect(): void;
+    emitRaw(event: string, payload?: unknown): void;
+    private teardownMedia;
+    private join;
+    private bindServerEvents;
+    private setState;
+    private emit;
+}
+
+type SabhaClientStatus = {
+    configured: boolean;
+    authenticated: boolean;
+    baseUrl: string;
+};
+declare class SabhaClient {
+    private config;
+    private tokens;
+    private user;
+    private http;
+    private authApi;
+    private meetingsApi;
+    private activeConnection;
+    private refreshPromise;
+    private mediaPolicy;
+    configure(config?: SabhaConfig): this;
+    getStatus(): SabhaClientStatus;
+    getAccessToken(): string | null;
+    getSessionCookie(): string | null;
+    getUser(): AuthUser | null;
+    getMediaPolicy(): MediaPolicy;
+    setMediaPolicy(policy: Partial<MediaPolicy>): void;
+    setTokens(tokens: SabhaTokens): void;
+    clearSession(): void;
+    login(input: LoginInput): Promise<AuthSession>;
+    register(input: RegisterInput): Promise<unknown>;
+    verifyEmail(input: VerifyEmailInput): Promise<AuthSession>;
+    refreshSession(): Promise<SabhaTokens>;
+    me(): Promise<AuthUser>;
+    logout(): Promise<void>;
+    listMeetings(): Promise<Meeting[]>;
+    createMeeting(input: CreateMeetingInput): Promise<Meeting>;
+    updateMeeting(meetingId: string, input: UpdateMeetingInput): Promise<Meeting>;
+    cancelMeeting(meetingId: string): Promise<void>;
+    startMeeting(input?: CreateMeetingInput & {
+        meetingId?: string;
+    }): Promise<{
+        meeting: Meeting;
+        connection: MeetingConnection;
+    }>;
+    connect(meetingId: string): Promise<MeetingConnection>;
+    getConnection(): MeetingConnection | null;
+    leaveMeeting(): Promise<void>;
+    private applySession;
+    private tryRefresh;
+    private getOrigin;
+    private ensureConfigured;
+    private auth;
+    private meetings;
+}
+declare function createSabhaClient(config?: SabhaConfig): SabhaClient;
+
+type SabhaProviderProps = SabhaConfig & {
+    children: ReactNode;
+    client?: SabhaClient;
+    autoLoadMeetings?: boolean;
+};
+declare function SabhaProvider({ children, client: clientProp, autoLoadMeetings, ...config }: SabhaProviderProps): react.JSX.Element;
+
+type SabhaContextValue = {
+    client: SabhaClient;
+    ready: boolean;
+    authenticated: boolean;
+    user: AuthUser | null;
+    meetings: Meeting[];
+    meetingsLoading: boolean;
+    connection: MeetingConnection | null;
+    connectionState: MeetingConnectionState;
+    mediaState: LocalMediaState;
+    error: Error | null;
+    refreshMeetings: () => Promise<Meeting[]>;
+    createMeeting: SabhaClient["createMeeting"];
+    updateMeeting: SabhaClient["updateMeeting"];
+    cancelMeeting: SabhaClient["cancelMeeting"];
+    startMeeting: SabhaClient["startMeeting"];
+    connect: SabhaClient["connect"];
+    leaveMeeting: SabhaClient["leaveMeeting"];
+    login: SabhaClient["login"];
+    logout: SabhaClient["logout"];
+    setAudioEnabled: (enabled: boolean) => Promise<LocalMediaState>;
+    setVideoEnabled: (enabled: boolean) => Promise<LocalMediaState>;
+    setScreenOff: (off: boolean) => Promise<LocalMediaState>;
+    startScreenShare: () => Promise<LocalMediaState>;
+    stopScreenShare: () => Promise<LocalMediaState>;
+    clearError: () => void;
+};
+
+declare function useSabha(): SabhaContextValue;
+declare function useSabhaMeetings(): {
+    meetings: Meeting[];
+    meetingsLoading: boolean;
+    refreshMeetings: () => Promise<Meeting[]>;
+    createMeeting: (input: CreateMeetingInput) => Promise<Meeting>;
+    updateMeeting: (meetingId: string, input: UpdateMeetingInput) => Promise<Meeting>;
+    cancelMeeting: (meetingId: string) => Promise<void>;
+    startMeeting: (input?: CreateMeetingInput & {
+        meetingId?: string;
+    }) => Promise<{
+        meeting: Meeting;
+        connection: MeetingConnection;
+    }>;
+    connect: (meetingId: string) => Promise<MeetingConnection>;
+    leaveMeeting: () => Promise<void>;
+    connection: MeetingConnection | null;
+    connectionState: MeetingConnectionState;
+    mediaState: LocalMediaState;
+    setAudioEnabled: (enabled: boolean) => Promise<LocalMediaState>;
+    setVideoEnabled: (enabled: boolean) => Promise<LocalMediaState>;
+    setScreenOff: (off: boolean) => Promise<LocalMediaState>;
+    startScreenShare: () => Promise<LocalMediaState>;
+    stopScreenShare: () => Promise<LocalMediaState>;
+    error: Error | null;
+};
+
+declare class SabhaError extends Error {
+    readonly status?: number;
+    readonly code?: string;
+    readonly details?: unknown;
+    constructor(message: string, options?: {
+        status?: number;
+        code?: string;
+        details?: unknown;
+        cause?: unknown;
+    });
+}
+declare function toSabhaError(error: unknown, fallback?: string): SabhaError;
+
+declare function normalizeMeeting(raw: unknown): Meeting;
+
+export { ContentProtection, DEFAULT_BASE_URL, DEFAULT_MEDIA_POLICY, MediaController, MeetingConnection, SabhaClient, SabhaError, SabhaProvider, createSabhaClient, normalizeMeeting, toSabhaError, useSabha, useSabhaMeetings };
+export type { AuthSession, AuthUser, CaptureAttemptType, CreateMeetingInput, LocalMediaState, LoginInput, MediaPolicy, MediaTrackKind, Meeting, MeetingConnectionOptions, MeetingConnectionState, MeetingInvitee, MeetingOrganizer, MeetingParticipant, MeetingRoomEventMap, RegisterInput, SabhaClientStatus, SabhaConfig, SabhaContextValue, SabhaOrg, SabhaProviderProps, SabhaSocketEvents, SabhaTokens, UpdateMeetingInput, VerifyEmailInput };