@nice2dev/ui-communication 1.0.2

package/dist/services/encryptionService.d.ts

@@ -0,0 +1,37 @@
+import { EncryptionAlgorithm, EncryptionConfig, EncryptionScope } from '../types/communicationTypes';
+
+declare function generateAesKey(bits: 128 | 256): Promise<CryptoKey>;
+declare function generateEcdhKeyPair(): Promise<CryptoKeyPair>;
+declare function importAesKey(base64Key: string, bits: 128 | 256): Promise<CryptoKey>;
+declare function exportAesKey(key: CryptoKey): Promise<string>;
+declare function exportPublicKeySpki(key: CryptoKey): Promise<string>;
+export interface EncryptionKeySet {
+    aes128?: CryptoKey;
+    aes256?: CryptoKey;
+    ecdhPrivate?: CryptoKey;
+    ecdhPublic?: CryptoKey;
+    ecdhSessionKeys?: Map<string, CryptoKey>;
+}
+export declare class EncryptionService {
+    private config;
+    private keys;
+    private ready;
+    constructor(config: EncryptionConfig);
+    init(): Promise<void>;
+    /** Export local ECDH public key — broadcast this to peers */
+    getPublicKeyForPeer(): Promise<string | null>;
+    /** Register a peer's ECDH public key to derive a shared session key */
+    registerPeerPublicKey(peerId: string, peerPublicKeyBase64: string): Promise<void>;
+    private resolveAlgorithm;
+    private getKey;
+    encrypt(plaintext: string, scope?: EncryptionScope, peerId?: string): Promise<string>;
+    decrypt(ciphertext: string, scope?: EncryptionScope, peerId?: string): Promise<string>;
+    /** Export the symmetric key for backup / persistence */
+    exportSymmetricKey(algo?: EncryptionAlgorithm): Promise<string | null>;
+    isEnabled(): boolean;
+    getConfig(): EncryptionConfig;
+    updateConfig(config: EncryptionConfig): void;
+}
+export declare function getEncryptionService(sessionId: string, config: EncryptionConfig): EncryptionService;
+export declare function disposeEncryptionService(sessionId: string): void;
+export { generateAesKey, exportAesKey, importAesKey, generateEcdhKeyPair, exportPublicKeySpki };

package/dist/services/recordingService.d.ts

@@ -0,0 +1,37 @@
+import { RecordingSession, RecordingState, TranscriptSegment } from '../types/communicationTypes';
+
+export interface RecordingServiceCallbacks {
+    onStateChange?: (state: RecordingState) => void;
+    onDataAvailable?: (blob: Blob) => void;
+    onTranscriptSegment?: (segment: TranscriptSegment) => void;
+    onError?: (error: Error) => void;
+}
+export declare class RecordingService {
+    private recorder;
+    private chunks;
+    private session;
+    private callbacks;
+    private recognition;
+    private segmentCounter;
+    constructor(callbacks?: RecordingServiceCallbacks);
+    start(stream: MediaStream, opts: {
+        sessionType: RecordingSession['sessionType'];
+        title?: string;
+        mimeType?: string;
+        timesliceMs?: number;
+        transcribe?: boolean;
+        speakerId?: string;
+        speakerName?: string;
+    }): RecordingSession;
+    pause(): void;
+    resume(): void;
+    stop(): RecordingSession | null;
+    private startTranscription;
+    private stopTranscription;
+    private chooseMimeType;
+    getState(): RecordingState;
+    getSession(): RecordingSession | null;
+    download(filename?: string): void;
+}
+export declare function getRecordingService(sessionId: string, callbacks?: RecordingServiceCallbacks): RecordingService;
+export declare function disposeRecordingService(sessionId: string): void;

package/dist/services/storageService.d.ts

@@ -0,0 +1,38 @@
+import { StorageConfig, RetentionRule, ChatMessage, WhiteboardSession, RecordingSession } from '../types/communicationTypes';
+import { EncryptionService } from './encryptionService';
+
+export declare class StorageService {
+    private adapter;
+    private config;
+    private encryption?;
+    constructor(config: StorageConfig, encryption?: EncryptionService);
+    private buildAdapter;
+    private getRuleFor;
+    private encode;
+    private decode;
+    saveMessages(conversationId: string, messages: ChatMessage[]): Promise<void>;
+    loadMessages(conversationId: string): Promise<ChatMessage[]>;
+    appendMessage(conversationId: string, message: ChatMessage): Promise<void>;
+    saveWhiteboardSnapshot(sessionId: string, session: WhiteboardSession): Promise<void>;
+    loadWhiteboardSnapshot(sessionId: string): Promise<WhiteboardSession | null>;
+    saveRecordingMeta(recording: RecordingSession): Promise<void>;
+    loadRecordingMeta(recordingId: string): Promise<RecordingSession | null>;
+    listRecordings(): Promise<RecordingSession[]>;
+    deleteRecording(recordingId: string): Promise<void>;
+    saveDocument(id: string, data: unknown): Promise<void>;
+    loadDocument(id: string): Promise<unknown>;
+    /**
+     * Run retention enforcement on all stored data.
+     * Should be called periodically (e.g., on app startup or daily).
+     */
+    enforceRetention(): Promise<{
+        archived: number;
+        deleted: number;
+    }>;
+    estimateUsageBytes(): Promise<number>;
+    updateConfig(config: StorageConfig): void;
+    getConfig(): StorageConfig;
+}
+export declare const DEFAULT_RETENTION_RULES: RetentionRule[];
+export declare function getStorageService(sessionId: string, config: StorageConfig, encryption?: EncryptionService): StorageService;
+export declare function disposeStorageService(sessionId: string): void;

package/dist/transport/communicationTransport.d.ts

@@ -0,0 +1,136 @@
+import { CallSession, CallType, RTCTransportConfig, TransportType } from '../types/communicationTypes';
+
+export interface ICommunicationTransport {
+    readonly type: TransportType;
+    connect(signalingUrl: string, userId: string): Promise<void>;
+    disconnect(): void;
+    isConnected(): boolean;
+    getLocalStream(constraints: MediaStreamConstraints): Promise<MediaStream>;
+    releaseLocalStream(): void;
+    startCall(participantIds: string[], type: CallType): Promise<CallSession>;
+    acceptCall(callId: string): Promise<void>;
+    declineCall(callId: string): void;
+    endCall(callId: string): void;
+    muteAudio(muted: boolean): void;
+    muteVideo(muted: boolean): void;
+    setAudioDevice(deviceId: string): Promise<void>;
+    setVideoDevice(deviceId: string): Promise<void>;
+    startScreenShare(): Promise<MediaStream>;
+    stopScreenShare(): void;
+    startRecording?(callId: string): Promise<void>;
+    stopRecording?(callId: string): void;
+    on(event: string, handler: (data: unknown) => void): void;
+    off(event: string, handler: (data: unknown) => void): void;
+}
+export interface TransportEventMap {
+    'call:incoming': {
+        callId: string;
+        callType: CallType;
+        callerId: string;
+    };
+    'call:accepted': {
+        callId: string;
+        participantId: string;
+    };
+    'call:ended': {
+        callId: string;
+        reason: string;
+    };
+    'call:declined': {
+        callId: string;
+        participantId: string;
+    };
+    'stream:added': {
+        participantId: string;
+        stream: MediaStream;
+    };
+    'stream:removed': {
+        participantId: string;
+    };
+    'peer:muted': {
+        participantId: string;
+        audio: boolean;
+        video: boolean;
+    };
+    'peer:speaking': {
+        participantId: string;
+        speaking: boolean;
+    };
+    'screen:started': {
+        participantId: string;
+        stream: MediaStream;
+    };
+    'screen:stopped': {
+        participantId: string;
+    };
+    'connection:quality': {
+        participantId: string;
+        quality: 'excellent' | 'good' | 'fair' | 'poor' | 'none';
+    };
+    'transport:connected': Record<string, never>;
+    'transport:disconnected': {
+        reason?: string;
+    };
+    'transport:error': {
+        error: Error;
+    };
+}
+declare class TypedEventEmitter {
+    private readonly listeners;
+    on(event: string, handler: (data: unknown) => void): void;
+    off(event: string, handler: (data: unknown) => void): void;
+    emit(event: string, data: unknown): void;
+    removeAll(): void;
+}
+export declare class WebRTCTransport extends TypedEventEmitter implements ICommunicationTransport {
+    readonly type: TransportType;
+    private config;
+    private signalingWs;
+    private localStream;
+    private screenStream;
+    private peers;
+    private userId;
+    private connected;
+    constructor(config?: RTCTransportConfig);
+    connect(signalingUrl: string, userId: string): Promise<void>;
+    disconnect(): void;
+    isConnected(): boolean;
+    getLocalStream(constraints: MediaStreamConstraints): Promise<MediaStream>;
+    releaseLocalStream(): void;
+    startCall(participantIds: string[], type: CallType): Promise<CallSession>;
+    acceptCall(callId: string): Promise<void>;
+    declineCall(callId: string): void;
+    endCall(callId: string): void;
+    muteAudio(muted: boolean): void;
+    muteVideo(muted: boolean): void;
+    setAudioDevice(deviceId: string): Promise<void>;
+    setVideoDevice(deviceId: string): Promise<void>;
+    startScreenShare(): Promise<MediaStream>;
+    stopScreenShare(): void;
+    private sendSignal;
+    private handleSignalingMessage;
+    private getOrCreatePeer;
+    private createPeerConnection;
+}
+export declare class MockTransport extends TypedEventEmitter implements ICommunicationTransport {
+    readonly type: TransportType;
+    private connected;
+    private localStream;
+    connect(_signalingUrl: string, _userId: string): Promise<void>;
+    disconnect(): void;
+    isConnected(): boolean;
+    getLocalStream(constraints: MediaStreamConstraints): Promise<MediaStream>;
+    releaseLocalStream(): void;
+    startCall(participantIds: string[], type: CallType): Promise<CallSession>;
+    acceptCall(callId: string): Promise<void>;
+    declineCall(callId: string): void;
+    endCall(callId: string): void;
+    muteAudio(_muted: boolean): void;
+    muteVideo(_muted: boolean): void;
+    setAudioDevice(_deviceId: string): Promise<void>;
+    setVideoDevice(_deviceId: string): Promise<void>;
+    startScreenShare(): Promise<MediaStream>;
+    stopScreenShare(): void;
+}
+export declare function createTransport(type: TransportType, config?: RTCTransportConfig): ICommunicationTransport;
+export {};