@ermis-network/ermis-chat-sdk 1.0.9 → 2.0.1

package/src/media_stream_sender.ts

@@ -1,400 +0,0 @@
-import { base64Encode, createPacketWithHeader } from './utils';
-import { AudioConfig, INodeCall, TransceiverState, VideoConfig } from './types';
-
-export class MediaStreamSender {
-  private videoEncoder: VideoEncoder | null = null;
-  private audioEncoder: AudioEncoder | null = null;
-  private videoReader: ReadableStreamDefaultReader<VideoFrame> | null = null;
-
-  private localStream: MediaStream | null = null;
-
-  private videoConfig: VideoConfig | null = null;
-  private audioConfig: AudioConfig | null = null;
-
-  private videoConfigSent: boolean = false;
-  private audioConfigSent: boolean = false;
-
-  private hasVideo: boolean = false;
-  private hasAudio: boolean = false;
-
-  private forceKeyFrame: boolean = false;
-
-  private nodeCall: INodeCall;
-
-  constructor(nodeCall: INodeCall) {
-    this.nodeCall = nodeCall;
-  }
-
-  /**
-   * Bắt đầu xử lý MediaStream
-   */
-  public async connect(address: string): Promise<void> {
-    try {
-      await this.nodeCall.connect(address);
-      await this.sendConnected();
-      await this.sendConfigs();
-    } catch (error) {
-      console.error('Error starting MediaStreamSender:', error);
-    }
-  }
-
-  public async sendConfigs(): Promise<void> {
-    try {
-      await this.sendTransceiverState(this.hasAudio, this.hasVideo);
-      await this.sendAudioConfig();
-
-      const videoTrack = this.localStream?.getVideoTracks()[0];
-      if (videoTrack) {
-        await this.sendVideoConfig();
-      }
-    } catch (error) {
-      console.error('Error sending configs:', error);
-    }
-  }
-
-  /**
-   * Dừng và reset encoders
-   */
-  public stop = (): void => {
-    if (this.videoReader) {
-      try {
-        this.videoReader.cancel('Stream stopped').catch(() => {});
-      } catch (e) {}
-      this.videoReader = null;
-    }
-
-    if (this.videoEncoder) {
-      try {
-        if (this.videoEncoder.state !== 'closed') {
-          this.videoEncoder.reset(); // Xả frame
-          this.videoEncoder.close();
-        }
-      } catch (e) {}
-      this.videoEncoder = null;
-    }
-
-    // Reset and close audio encoder
-    if (this.audioEncoder) {
-      try {
-        if (this.audioEncoder.state !== 'closed') {
-          this.audioEncoder.reset();
-          this.audioEncoder.close();
-        }
-      } catch (e) {}
-      this.audioEncoder = null;
-    }
-
-    // Reset configs and flags
-    this.videoConfig = null;
-    this.audioConfig = null;
-
-    this.videoConfigSent = false;
-    this.audioConfigSent = false;
-    this.hasVideo = false;
-    this.hasAudio = false;
-
-    if (this.localStream) {
-      this.localStream.getTracks().forEach((track) => track.stop());
-      this.localStream = null;
-    }
-  };
-
-  public initAudioEncoder = (audioTrack: MediaStreamTrack): void => {
-    this.localStream = new MediaStream([audioTrack]);
-    this.audioConfigSent = false;
-    this.hasAudio = !!audioTrack;
-
-    const audioEncoder = new AudioEncoder({
-      output: (chunk, metadata) => {
-        if (metadata?.decoderConfig && !this.audioConfigSent) {
-          let description: string | undefined = undefined;
-          if (metadata.decoderConfig.description) {
-            description = base64Encode(metadata.decoderConfig.description as ArrayBuffer);
-          }
-
-          this.audioConfig = {
-            codec: metadata.decoderConfig.codec ?? 'opus',
-            sampleRate: metadata.decoderConfig.sampleRate ?? 48000,
-            numberOfChannels: metadata.decoderConfig.numberOfChannels ?? 1,
-            ...(description && { description }),
-          };
-        }
-
-        if (chunk && this.isReadyToSendData('audio')) {
-          const data = new ArrayBuffer(chunk.byteLength);
-          chunk.copyTo(data);
-          // const timestamp = Math.floor(chunk.timestamp / 1000);
-          const timestamp = chunk.timestamp;
-
-          const packet = createPacketWithHeader(data, timestamp, 'audio', null);
-          this.sendPacketOrQueue(packet, 'audio', null);
-        }
-      },
-      error: (e) => console.error('AudioEncoder error:', e),
-    });
-
-    audioEncoder.configure({
-      codec: 'mp4a.40.2',
-      sampleRate: 48000,
-      numberOfChannels: 1,
-      bitrate: 128000,
-    });
-
-    this.audioEncoder = audioEncoder;
-    this.processAudioFrames(audioTrack);
-  };
-
-  public initVideoEncoder(videoTrack: MediaStreamTrack): void {
-    if (this.localStream) {
-      this.localStream.addTrack(videoTrack);
-    }
-
-    this.videoConfigSent = false;
-    this.hasVideo = !!videoTrack;
-
-    const settings = videoTrack.getSettings();
-    const videoWidth = settings.width || 1280;
-    const videoHeight = settings.height || 720;
-
-    const videoEncoder = new VideoEncoder({
-      output: async (chunk, metadata) => {
-        if (metadata?.decoderConfig && !this.videoConfigSent) {
-          let description: string | undefined = undefined;
-          if (metadata.decoderConfig.description) {
-            description = base64Encode(metadata.decoderConfig.description as ArrayBuffer);
-          }
-
-          this.videoConfig = {
-            codec: metadata.decoderConfig.codec ?? 'hev1.1.6.L93.B0',
-            codedWidth: metadata.decoderConfig.codedWidth ?? videoWidth,
-            codedHeight: metadata.decoderConfig.codedHeight ?? videoHeight,
-            frameRate: 30.0,
-            orientation: 0,
-            ...(description && { description }),
-          };
-
-          await this.sendVideoConfig();
-        }
-
-        if (chunk && this.isReadyToSendData('video')) {
-          const data = new ArrayBuffer(chunk.byteLength);
-          chunk.copyTo(data);
-          const frameType = chunk.type === 'key' ? 'video-key' : 'video-delta';
-          // const timestamp = Math.floor(chunk.timestamp / 1000);
-          const timestamp = chunk.timestamp;
-
-          const packet = createPacketWithHeader(data, timestamp, frameType, null);
-          this.sendPacketOrQueue(packet, 'video', frameType);
-        }
-      },
-      error: (e) => console.error('VideoEncoder error:', e),
-    });
-
-    videoEncoder.configure({
-      codec: 'hev1.1.6.L93.B0',
-      width: videoWidth,
-      height: videoHeight,
-      bitrate: 500_000,
-      framerate: 30,
-      latencyMode: 'realtime',
-      hardwareAcceleration: 'prefer-hardware',
-    });
-
-    this.videoEncoder = videoEncoder;
-    this.processVideoFrames(videoTrack);
-  }
-
-  public initEncoders = (stream: MediaStream): void => {
-    const videoTrack = stream.getVideoTracks()[0];
-    const audioTrack = stream.getAudioTracks()[0];
-
-    if (audioTrack) {
-      this.initAudioEncoder(audioTrack);
-    }
-
-    if (videoTrack) {
-      this.initVideoEncoder(videoTrack);
-    }
-  };
-
-  public sendTransceiverState = async (audioEnable: boolean, videoEnable: boolean) => {
-    const state: TransceiverState = {
-      audio_enable: !!audioEnable,
-      video_enable: !!videoEnable,
-    };
-    const configPacket = createPacketWithHeader(null, null, 'transciverState', state);
-    await this.nodeCall.sendControlFrame(configPacket);
-  };
-
-  public async replaceVideoTrack(track: MediaStreamTrack): Promise<void> {
-    // 1. Dừng reader của track cũ (quan trọng)
-    if (this.videoReader) {
-      try {
-        // Việc gọi cancel sẽ làm Promise tại dòng await read() bên dưới throw lỗi hoặc trả về done
-        await this.videoReader.cancel('Replacing track');
-      } catch (e) {
-        // Bỏ qua lỗi khi cancel
-      }
-      this.videoReader = null;
-    }
-
-    if (track) {
-      this.processVideoFrames(track);
-    }
-  }
-
-  public async replaceAudioTrack(track: MediaStreamTrack): Promise<void> {
-    if (track) {
-      this.processAudioFrames(track);
-    }
-  }
-
-  /**
-   * Yêu cầu gửi keyframe ngay lập tức (được gọi khi nhận REQUEST_KEY_FRAME từ receiver)
-   */
-  public requestKeyFrame = (): void => {
-    console.log('📥 KeyFrame requested');
-    this.forceKeyFrame = true;
-  };
-
-  // ================= PRIVATE METHODS =================
-
-  private processVideoFrames = async (videoTrack: MediaStreamTrack) => {
-    try {
-      // @ts-ignore: MediaStreamTrackProcessor is explicitly defined in WebCodecs types
-      const videoProcessor = new MediaStreamTrackProcessor({ track: videoTrack });
-      this.videoReader = videoProcessor.readable.getReader();
-
-      let frameCounter = 0;
-      while (true) {
-        if (!this.videoReader) break;
-
-        const { done, value: frame } = await this.videoReader.read();
-        if (done) break;
-
-        if (!this.videoEncoder) {
-          frame?.close();
-          break;
-        }
-
-        if (frame) {
-          frameCounter += 1;
-          const keyFrame = frameCounter % 60 === 0 || this.forceKeyFrame;
-          if (this.forceKeyFrame) {
-            console.log('📤 Sending forced KeyFrame');
-            this.forceKeyFrame = false;
-          }
-          try {
-            this.videoEncoder.encode(frame, { keyFrame });
-          } catch (err) {
-            console.error('Encode error:', err);
-          } finally {
-            frame.close();
-          }
-        }
-      }
-    } catch (error: any) {
-      console.error(`Error processing video frames: ${error.message}`);
-    } finally {
-      if (this.videoReader) {
-        try {
-          this.videoReader.releaseLock();
-        } catch (e) {}
-        // this.videoReader = null;
-      }
-    }
-  };
-
-  private processAudioFrames = async (audioTrack: MediaStreamTrack) => {
-    // @ts-ignore
-    const audioProcessor = new MediaStreamTrackProcessor({ track: audioTrack });
-    const audioReader = audioProcessor.readable.getReader();
-
-    try {
-      while (true) {
-        const { done, value: frame } = await audioReader.read();
-        if (done) break;
-
-        if (!this.audioEncoder) {
-          frame?.close();
-          break;
-        }
-
-        if (frame) {
-          try {
-            this.audioEncoder.encode(frame);
-          } catch (err) {
-            console.error('Audio Encoding error:', err);
-          } finally {
-            frame.close();
-          }
-        }
-      }
-    } catch (error: any) {
-      console.error(`Error processing audio frames: ${error.message}`);
-    }
-  };
-
-  private isReadyToSendData = (type: 'video' | 'audio'): boolean => {
-    const videoReady = !this.hasVideo || this.videoConfigSent;
-    const audioReady = !this.hasAudio || this.audioConfigSent;
-    const allConfigsSent = videoReady && audioReady;
-
-    if (type === 'video') {
-      return allConfigsSent && this.videoConfigSent;
-    } else if (type === 'audio') {
-      return allConfigsSent && this.audioConfigSent;
-    }
-
-    return false;
-  };
-
-  private sendVideoConfig = async () => {
-    if (this.videoConfig && !this.videoConfigSent) {
-      try {
-        const configPacket = createPacketWithHeader(null, null, 'videoConfig', this.videoConfig);
-        await this.nodeCall.sendControlFrame(configPacket);
-        this.videoConfigSent = true;
-      } catch (error) {
-        console.error('Error sending video config:', error);
-      }
-    }
-  };
-
-  private sendAudioConfig = async () => {
-    if (this.audioConfig && !this.audioConfigSent) {
-      try {
-        const configPacket = createPacketWithHeader(null, null, 'audioConfig', this.audioConfig);
-        await this.nodeCall.sendControlFrame(configPacket);
-        this.audioConfigSent = true;
-      } catch (error) {
-        console.error('Error sending audio config:', error);
-      }
-    }
-  };
-
-  public sendConnected = async () => {
-    const configPacket = createPacketWithHeader(null, null, 'connected', null);
-    await this.nodeCall.sendControlFrame(configPacket);
-  };
-
-  private sendPacketOrQueue = async (
-    packet: Uint8Array,
-    type: 'video' | 'audio',
-    frameType: 'video-key' | 'video-delta' | null,
-  ) => {
-    if (!this.isReadyToSendData(type)) {
-      return;
-    }
-
-    if (type === 'audio') {
-      await this.nodeCall.sendAudioFrame(packet);
-    } else if (type === 'video') {
-      if (frameType === 'video-key') {
-        await this.nodeCall.beginWithGop(packet);
-      } else if (frameType === 'video-delta') {
-        await this.nodeCall.sendFrame(packet);
-      }
-    }
-  };
-}

package/src/shims/empty.ts

@@ -1 +0,0 @@
-export default null;

package/src/signal_message.ts

@@ -1,146 +0,0 @@
-/**
- * Call type constants for signal messages.
- */
-export const CallType = {
-  AUDIO: 'audio',
-  VIDEO: 'video',
-} as const;
-
-export type CallTypeValue = (typeof CallType)[keyof typeof CallType];
-
-/**
- * Result of parsing a signal message.
- */
-export interface SignalMessageResult {
-  text: string;
-  duration: string;
-  callType: CallTypeValue | '';
-  color: string;
-}
-
-/**
- * Format duration from milliseconds to "X min, Y sec" format.
- */
-function formatDuration(durationMs: string): string {
-  if (!durationMs) return '';
-  const ms = parseInt(durationMs, 10);
-  if (isNaN(ms) || ms <= 0) return '';
-  const totalSeconds = Math.floor(ms / 1000);
-  const minutes = Math.floor(totalSeconds / 60);
-  const seconds = totalSeconds % 60;
-  return `${minutes} min, ${seconds} sec`;
-}
-
-/**
- * Parse a raw signal message string into a structured object
- * containing text, duration, call type, and color.
- *
- * Signal messages represent call events. The raw format is:
- * `"<formatId> <callerId> [<enderId> <duration>]"`
- *
- * @param value    - Raw signal message string from the server
- * @param myUserId - The current user's ID (from client.userID)
- * @returns          Parsed signal message object, or null if input is empty
- */
-export function parseSignalMessage(
-  value: string,
-  myUserId: string,
-): SignalMessageResult | null {
-  if (!value || typeof value !== 'string') return null;
-
-  const trimmed = value.trim();
-  if (!trimmed) return null;
-
-  const parts = trimmed.split(' ');
-  const number = parseInt(parts[0], 10);
-  const callerId = parts[1] ?? '';
-  const isMe = myUserId === callerId;
-
-  let enderId = '';
-  let duration = '';
-  let callType: CallTypeValue | '' = '';
-  let color = '';
-
-  if (number === 3 || number === 6) {
-    enderId = parts[2] ?? '';
-    duration = parts[3] === '0' ? '' : (parts[3] ?? '');
-  }
-
-  let text: string;
-  switch (number) {
-    case 1: // AudioCallStarted
-      text = isMe ? 'Calling...' : 'Incoming audio call...';
-      callType = CallType.AUDIO;
-      color = '#54D62C';
-      break;
-    case 2: // AudioCallMissed
-      text = isMe ? 'Outgoing audio call' : 'You missed audio call';
-      callType = CallType.AUDIO;
-      color = '#FF4842';
-      break;
-    case 3: // AudioCallEnded
-      if (duration) {
-        text = isMe ? 'Outgoing audio call' : 'Incoming audio call';
-        color = '#54D62C';
-      } else {
-        if (enderId === myUserId) {
-          text = 'You cancel audio call';
-        } else {
-          text = 'You missed audio call';
-        }
-        color = '#FF4842';
-      }
-      callType = CallType.AUDIO;
-      break;
-    case 4: // VideoCallStarted
-      text = isMe ? 'Calling...' : 'Incoming video call...';
-      callType = CallType.VIDEO;
-      color = '#54D62C';
-      break;
-    case 5: // VideoCallMissed
-      text = isMe ? 'Outgoing video call' : 'You missed video call';
-      callType = CallType.VIDEO;
-      color = '#FF4842';
-      break;
-    case 6: // VideoCallEnded
-      if (duration) {
-        text = isMe ? 'Outgoing video call' : 'Incoming video call';
-        color = '#54D62C';
-      } else {
-        if (enderId === myUserId) {
-          text = 'You cancel video call';
-        } else {
-          text = 'You missed video call';
-        }
-        color = '#FF4842';
-      }
-      callType = CallType.VIDEO;
-      break;
-    case 7: // AudioCallRejected
-      text = isMe ? 'Recipient rejected audio call' : 'You rejected audio call';
-      callType = CallType.AUDIO;
-      color = '#FF4842';
-      break;
-    case 8: // VideoCallRejected
-      text = isMe ? 'Recipient rejected video call' : 'You rejected video call';
-      callType = CallType.VIDEO;
-      color = '#FF4842';
-      break;
-    case 9: // AudioCallBusy
-      text = isMe ? 'Recipient was busy' : 'You missed audio call';
-      callType = CallType.AUDIO;
-      color = '#FF4842';
-      break;
-    case 10: // VideoCallBusy
-      text = isMe ? 'Recipient was busy' : 'You missed video call';
-      callType = CallType.VIDEO;
-      color = '#FF4842';
-      break;
-    default:
-      text = trimmed;
-      callType = '';
-      color = '';
-  }
-
-  return { text, duration: formatDuration(duration), callType, color };
-}

package/src/system_message.ts

@@ -1,117 +0,0 @@
-/**
- * Duration lookup: milliseconds → human-readable text.
- */
-const DURATION_MAP: Record<string, string> = {
-  '10000': '10 seconds',
-  '30000': '30 seconds',
-  '60000': '1 minute',
-  '300000': '5 minutes',
-  '900000': '15 minutes',
-  '3600000': '60 minutes',
-};
-
-/**
- * Resolve a user ID to a display name using the provided map.
- * Falls back to the raw userId if no entry is found.
- */
-function resolveUser(userId: string, userMap: Record<string, string>): string {
-  return userMap[userId] ?? userId;
-}
-
-/**
- * Parse a raw system message string into a human-readable English sentence.
- *
- * The raw format is: `"<formatId> <userID> [<param1> <param2> ...]"`
- *
- * @param value   - Raw system message string from the server
- * @param userMap - Mapping of user IDs → display names
- * @returns         Parsed English text, or the original string if the format is unknown
- */
-export function parseSystemMessage(
-  value: string,
-  userMap: Record<string, string>,
-): string {
-  if (!value || typeof value !== 'string') return value ?? '';
-
-  const trimmed = value.trim();
-  if (!trimmed) return '';
-
-  const parts = trimmed.split(' ');
-  const formatId = parts[0];
-  const userId = parts[1] ?? '';
-  const userName = userId ? resolveUser(userId, userMap) : 'User';
-
-  switch (formatId) {
-    // 1: userName changed the channel name to channelName (may contain spaces)
-    case '1': {
-      const channelName = parts.slice(2).join(' ');
-      return `${userName} changed the channel name to ${channelName}.`;
-    }
-
-    // 2–13, 16–17: single-user actions
-    case '2':
-      return `${userName} changed the channel avatar.`;
-    case '3':
-      return `${userName} changed the channel description.`;
-    case '4':
-      return `${userName} was removed from the channel.`;
-    case '5':
-      return `${userName} was banned.`;
-    case '6':
-      return `${userName} was unbanned.`;
-    case '7':
-      return `${userName} was promoted to moderator.`;
-    case '8':
-      return `${userName} was demoted from moderator.`;
-    case '9':
-      return `${userName}'s permissions were updated.`;
-    case '10':
-      return `${userName} joined the channel.`;
-    case '11':
-      return `${userName} declined the channel invitation.`;
-    case '12':
-      return `${userName} left the channel.`;
-    case '13':
-      return `${userName} cleared the chat history.`;
-
-    // 14: channel type change (true = public, false = private)
-    case '14': {
-      const rawType = parts[2] ?? '';
-      const channelType = rawType === 'true' ? 'public' : 'private';
-      return `${userName} changed the channel to ${channelType}.`;
-    }
-
-    // 15: cooldown toggle / duration
-    case '15': {
-      const duration = parts[2] ?? '0';
-      if (duration === '0') {
-        return `${userName} disabled cooldown.`;
-      }
-      const durationText = DURATION_MAP[duration] ?? `${duration}ms`;
-      return `${userName} enabled cooldown for ${durationText}.`;
-    }
-
-    case '16':
-      return `${userName} updated the banned words.`;
-    case '17':
-      return `${userName} was added to the channel.`;
-
-    // 18: admin transfer (two user IDs)
-    case '18': {
-      const oldUserId = parts[1] ?? '';
-      const newUserId = parts[2] ?? '';
-      const oldUserName = oldUserId ? resolveUser(oldUserId, userMap) : 'User';
-      const newUserName = newUserId ? resolveUser(newUserId, userMap) : 'User';
-      return `Admin ${oldUserName} left and assigned ${newUserName} as the new admin.`;
-    }
-
-    // 19–20: pin / unpin (userId + msgID)
-    case '19':
-      return `${userName} pinned a message.`;
-    case '20':
-      return `${userName} unpinned a message.`;
-
-    default:
-      return trimmed;
-  }
-}

package/src/token_manager.ts

@@ -1,48 +0,0 @@
-import { ExtendableGenerics, DefaultGenerics, UserResponse } from './types';
-
-/**
- * TokenManager
- *
- * Manages token storage and retrieval for the chat client.
- */
-export class TokenManager<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> {
-  loadTokenPromise: Promise<string> | null;
-  token?: string;
-  user?: UserResponse<ErmisChatGenerics>;
-
-  constructor() {
-    this.loadTokenPromise = null;
-  }
-
-  /**
-   * Set the static string token.
-   */
-  setTokenOrProvider = async (tokenOrProvider: string | null, user: UserResponse<ErmisChatGenerics>) => {
-    this.user = user;
-
-    if (typeof tokenOrProvider === 'string') {
-      this.token = tokenOrProvider;
-    }
-
-    this.loadTokenPromise = Promise.resolve(this.token as string);
-  };
-
-  /**
-   * Resets the token manager.
-   */
-  reset = () => {
-    this.token = undefined;
-    this.user = undefined;
-    this.loadTokenPromise = null;
-  };
-
-  /**
-   * Resolves when token is ready.
-   */
-  tokenReady = () => this.loadTokenPromise;
-
-  /** Returns the current token */
-  getToken = () => {
-    return this.token;
-  };
-}