@100mslive/hls-player 0.4.3-alpha.3 → 0.4.3-alpha.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@100mslive/hls-player",
-  "version": "0.4.3-alpha.3",
+  "version": "0.4.3-alpha.4",
   "description": "HLS client library which uses HTML5 Video element and Media Source Extension for playback",
   "main": "dist/index.cjs.js",
   "module": "dist/index.js",
@@ -11,7 +11,6 @@
     "directory": "packages/hls-player"
   },
   "files": [
-    "src",
     "dist"
   ],
   "exports": {
@@ -36,7 +35,7 @@
   "author": "100ms",
   "license": "MIT",
   "dependencies": {
-    "@100mslive/hls-stats": "0.5.3-alpha.3",
+    "@100mslive/hls-stats": "0.5.3-alpha.4",
     "eventemitter2": "^6.4.9",
     "hls.js": "1.4.12"
   },
@@ -48,5 +47,5 @@
     "conferencing",
     "100ms"
   ],
-  "gitHead": "43ae4fb9ef619c492c010d185fe7200bd1e3fa45"
+  "gitHead": "f4feef2572dd196edc136c16a0b0debbfb00f39a"
 }

package/src/controllers/HMSHLSPlayer.ts

@@ -1,399 +0,0 @@
-import { HlsPlayerStats, HlsStats } from '@100mslive/hls-stats';
-import Hls, { ErrorData, HlsConfig, Level, LevelParsed } from 'hls.js';
-import { HMSHLSTimedMetadata } from './HMSHLSTimedMetadata';
-import { HMSHLSErrorFactory } from '../error/HMSHLSErrorFactory';
-import { HMSHLSException } from '../error/HMSHLSException';
-import { HMSHLSPlayerEventEmitter, HMSHLSPlayerListeners, IHMSHLSPlayerEventEmitter } from '../interfaces/events';
-import { HMSHLSLayer } from '../interfaces/IHMSHLSLayer';
-import IHMSHLSPlayer from '../interfaces/IHMSHLSPlayer';
-import { HLS_DEFAULT_ALLOWED_MAX_LATENCY_DELAY, HLSPlaybackState, HMSHLSPlayerEvents } from '../utilies/constants';
-import { mapLayer, mapLayers } from '../utilies/utils';
-
-export class HMSHLSPlayer implements IHMSHLSPlayer, IHMSHLSPlayerEventEmitter {
-  private _hls: Hls;
-  private _hlsUrl: string;
-  private _hlsStats: HlsStats;
-  private _videoEl: HTMLVideoElement;
-  private _emitter: HMSHLSPlayerEventEmitter;
-  private _subscribeHlsStats?: (() => void) | null = null;
-  private _isLive: boolean;
-  private _volume: number;
-  private _metaData: HMSHLSTimedMetadata;
-  private readonly TAG = '[HMSHLSPlayer]';
-  /**
-   * Initiliaze the player with hlsUrl and video element
-   * @remarks If video element is not passed, we will create one and call a method getVideoElement get element
-   * @param hlsUrl required - Pass hls url to
-   * @param videoEl optional field - HTML video element
-   */
-  constructor(hlsUrl: string, videoEl?: HTMLVideoElement) {
-    this._hls = new Hls(this.getPlayerConfig());
-    this._emitter = new HMSHLSPlayerEventEmitter();
-    this._hlsUrl = hlsUrl;
-    this._videoEl = videoEl || this.createVideoElement();
-    try {
-      const url = new URL(hlsUrl);
-      if (!url.pathname.endsWith('m3u8')) {
-        throw HMSHLSErrorFactory.HLSMediaError.hlsURLNotFound('Invalid URL, pass m3u8 url');
-      }
-    } catch (e) {
-      throw HMSHLSErrorFactory.HLSMediaError.hlsURLNotFound();
-    }
-    this._hls.loadSource(hlsUrl);
-    this._hls.attachMedia(this._videoEl);
-    this._isLive = true;
-    this._volume = this._videoEl.volume * 100;
-    this._hlsStats = new HlsStats(this._hls, this._videoEl);
-    this.listenHLSEvent();
-    this._metaData = new HMSHLSTimedMetadata(this._hls, this._videoEl, this.emitEvent);
-    this.seekToLivePosition();
-  }
-
-  /**
-   * @remarks It will create a video element with playiniline true.
-   * @returns HTML video element
-   */
-  private createVideoElement(): HTMLVideoElement {
-    if (this._videoEl) {
-      return this._videoEl;
-    }
-    const video: HTMLVideoElement = document.createElement('video');
-    video.playsInline = true;
-    video.controls = false;
-    video.autoplay = true;
-    return video;
-  }
-
-  /**
-   * @returns get html video element
-   */
-  getVideoElement(): HTMLVideoElement {
-    return this._videoEl;
-  }
-  /**
-   *  Subscribe to hls stats
-   */
-  private subscribeStats = (interval = 2000) => {
-    this._subscribeHlsStats = this._hlsStats.subscribe((state: HlsPlayerStats) => {
-      this.emitEvent(HMSHLSPlayerEvents.STATS, state);
-    }, interval);
-  };
-  /**
-   * Unsubscribe to hls stats
-   */
-  private unsubscribeStats = () => {
-    if (this._subscribeHlsStats) {
-      this._subscribeHlsStats();
-    }
-  };
-  // reset the controller
-  reset() {
-    if (this._hls && this._hls.media) {
-      this._hls.detachMedia();
-      this.unsubscribeStats();
-    }
-    if (this._metaData) {
-      this._metaData.unregisterListener();
-    }
-    if (Hls.isSupported()) {
-      this._hls.off(Hls.Events.MANIFEST_LOADED, this.manifestLoadedHandler);
-      this._hls.off(Hls.Events.LEVEL_UPDATED, this.levelUpdatedHandler);
-      this._hls.off(Hls.Events.ERROR, this.handleHLSException);
-    }
-    if (this._videoEl) {
-      this._videoEl.removeEventListener('play', this.playEventHandler);
-      this._videoEl.removeEventListener('pause', this.pauseEventHandler);
-      this._videoEl.removeEventListener('timeupdate', this.handleTimeUpdateListener);
-      this._videoEl.removeEventListener('volumechange', this.volumeEventHandler);
-    }
-    this.removeAllListeners();
-  }
-
-  on = <E extends HMSHLSPlayerEvents>(eventName: E, listener: HMSHLSPlayerListeners<E>) => {
-    this._emitter.on(eventName, listener);
-  };
-
-  off = <E extends HMSHLSPlayerEvents>(eventName: E, listener: HMSHLSPlayerListeners<E>) => {
-    this._emitter.off(eventName, listener);
-  };
-
-  emitEvent = <E extends HMSHLSPlayerEvents>(
-    eventName: E,
-    eventObject: Parameters<HMSHLSPlayerListeners<E>>[0],
-  ): boolean => {
-    if (eventName === HMSHLSPlayerEvents.ERROR) {
-      const hlsError = eventObject as HMSHLSException;
-      if (hlsError?.isTerminal) {
-        // send analytics event
-        window?.__hms?.sdk?.sendHLSAnalytics(hlsError);
-      }
-    }
-    return this._emitter.emitEvent(eventName, eventObject);
-  };
-
-  private removeAllListeners = <E extends HMSHLSPlayerEvents>(eventName?: E): void => {
-    this._emitter.removeAllListeners(eventName);
-  };
-
-  public get volume(): number {
-    return this._volume;
-  }
-
-  setVolume(volume: number) {
-    this._videoEl.volume = volume / 100;
-    this._volume = volume;
-  }
-
-  getLayer(): HMSHLSLayer | null {
-    if (this._hls && this._hls.currentLevel !== -1) {
-      const currentLevel = this._hls?.levels.at(this._hls?.currentLevel);
-      return currentLevel ? mapLayer(currentLevel) : null;
-    }
-    return null;
-  }
-
-  setLayer(layer: HMSHLSLayer): void {
-    if (this._hls) {
-      const current = this._hls.levels.findIndex((level: Level) => {
-        return level?.attrs?.RESOLUTION === layer?.resolution;
-      });
-      this._hls.nextLevel = current;
-    }
-    return;
-  }
-  /**
-   * set current stream to Live
-   */
-  async seekToLivePosition() {
-    let end = 0;
-    if (this._videoEl.buffered.length > 0) {
-      end = this._videoEl.buffered.end(this._videoEl.buffered.length - 1);
-    }
-    this._videoEl.currentTime = this._hls.liveSyncPosition || end;
-    if (this._videoEl.paused) {
-      try {
-        await this.playVideo();
-      } catch (err) {
-        console.error(this.TAG, 'Attempt to jump to live position Failed.', err);
-      }
-    }
-  }
-  /**
-   * Play stream
-   */
-  play = async () => {
-    await this.playVideo();
-  };
-  /**
-   * Pause stream
-   */
-  pause = () => {
-    this.pauseVideo();
-  };
-  /**
-   * It will update the video element current time
-   * @param seekValue Pass currentTime in second
-   */
-  seekTo = (seekValue: number) => {
-    this._videoEl.currentTime = seekValue;
-  };
-
-  hasCaptions = () => {
-    return this._hls.subtitleTracks.length > 0;
-  };
-
-  toggleCaption = () => {
-    // no subtitles, do nothing
-    if (!this.hasCaptions()) {
-      return;
-    }
-    this._hls.subtitleDisplay = !this._hls.subtitleDisplay;
-    this.emitEvent(HMSHLSPlayerEvents.CAPTION_ENABLED, this._hls.subtitleDisplay);
-  };
-
-  private playVideo = async () => {
-    try {
-      if (this._videoEl.paused) {
-        await this._videoEl.play();
-      }
-    } catch (error) {
-      console.debug(this.TAG, 'Play failed with error', (error as Error).message);
-      if ((error as Error).name === 'NotAllowedError') {
-        this.emitEvent(HMSHLSPlayerEvents.AUTOPLAY_BLOCKED, HMSHLSErrorFactory.HLSMediaError.autoplayFailed());
-      }
-    }
-  };
-  private pauseVideo = () => {
-    if (!this._videoEl.paused) {
-      this._videoEl.pause();
-    }
-  };
-  private playEventHandler = () => {
-    this.emitEvent(HMSHLSPlayerEvents.PLAYBACK_STATE, {
-      state: HLSPlaybackState.playing,
-    });
-  };
-  private pauseEventHandler = () => {
-    this.emitEvent(HMSHLSPlayerEvents.PLAYBACK_STATE, {
-      state: HLSPlaybackState.paused,
-    });
-  };
-  private volumeEventHandler = () => {
-    this._volume = Math.round(this._videoEl.volume * 100);
-  };
-
-  private reConnectToStream = () => {
-    window.addEventListener(
-      'online',
-      () => {
-        this._hls.startLoad();
-      },
-      {
-        once: true,
-      },
-    );
-  };
-  // eslint-disable-next-line complexity
-  private handleHLSException = (_: any, data: ErrorData) => {
-    console.error(this.TAG, `error type ${data.type} with details ${data.details} is fatal ${data.fatal}`);
-    const details = data.error?.message || data.err?.message || '';
-    const detail = {
-      details: details,
-      fatal: data.fatal,
-    };
-    if (!detail.fatal) {
-      return;
-    }
-    switch (data.details) {
-      case Hls.ErrorDetails.MANIFEST_INCOMPATIBLE_CODECS_ERROR: {
-        const error = HMSHLSErrorFactory.HLSMediaError.manifestIncompatibleCodecsError(detail);
-        this.emitEvent(HMSHLSPlayerEvents.ERROR, error);
-        break;
-      }
-      case Hls.ErrorDetails.FRAG_DECRYPT_ERROR: {
-        const error = HMSHLSErrorFactory.HLSMediaError.fragDecryptError(detail);
-        this.emitEvent(HMSHLSPlayerEvents.ERROR, error);
-        break;
-      }
-      case Hls.ErrorDetails.BUFFER_INCOMPATIBLE_CODECS_ERROR: {
-        const error = HMSHLSErrorFactory.HLSMediaError.bufferIncompatibleCodecsError(detail);
-        this.emitEvent(HMSHLSPlayerEvents.ERROR, error);
-        break;
-      }
-      // Below ones are network related errors
-      case Hls.ErrorDetails.MANIFEST_LOAD_ERROR: {
-        const error = HMSHLSErrorFactory.HLSNetworkError.manifestLoadError(detail);
-        this.emitEvent(HMSHLSPlayerEvents.ERROR, error);
-        break;
-      }
-      case Hls.ErrorDetails.MANIFEST_PARSING_ERROR: {
-        const error = HMSHLSErrorFactory.HLSNetworkError.manifestParsingError(detail);
-        this.emitEvent(HMSHLSPlayerEvents.ERROR, error);
-        break;
-      }
-      case Hls.ErrorDetails.LEVEL_LOAD_ERROR: {
-        const error = HMSHLSErrorFactory.HLSNetworkError.layerLoadError(detail);
-        if (!navigator.onLine) {
-          this.reConnectToStream();
-        } else {
-          this.emitEvent(HMSHLSPlayerEvents.ERROR, error);
-        }
-        break;
-      }
-      default: {
-        const error = HMSHLSErrorFactory.HLSError(detail, data.type, data.details);
-        this.emitEvent(HMSHLSPlayerEvents.ERROR, error);
-        break;
-      }
-    }
-  };
-  private manifestLoadedHandler = (_: any, { levels }: { levels: LevelParsed[] }) => {
-    const layers: HMSHLSLayer[] = mapLayers(this.removeAudioLevels(levels));
-    this.emitEvent(HMSHLSPlayerEvents.MANIFEST_LOADED, {
-      layers,
-    });
-  };
-  private levelUpdatedHandler = (_: any, { level }: { level: number }) => {
-    const qualityLayer: HMSHLSLayer = mapLayer(this._hls.levels[level]);
-    this.emitEvent(HMSHLSPlayerEvents.LAYER_UPDATED, {
-      layer: qualityLayer,
-    });
-  };
-
-  private handleTimeUpdateListener = (_: Event) => {
-    this.emitEvent(HMSHLSPlayerEvents.CURRENT_TIME, this._videoEl.currentTime);
-    const live = this._hls.liveSyncPosition
-      ? this._hls.liveSyncPosition - this._videoEl.currentTime <= HLS_DEFAULT_ALLOWED_MAX_LATENCY_DELAY
-      : false;
-    if (this._isLive !== live) {
-      this._isLive = live;
-      this.emitEvent(HMSHLSPlayerEvents.SEEK_POS_BEHIND_LIVE_EDGE, {
-        isLive: this._isLive,
-      });
-    }
-  };
-  /**
-   * Listen to hlsjs and video related events
-   */
-  private listenHLSEvent() {
-    if (Hls.isSupported()) {
-      this._hls.on(Hls.Events.MANIFEST_LOADED, this.manifestLoadedHandler);
-      this._hls.on(Hls.Events.LEVEL_UPDATED, this.levelUpdatedHandler);
-      this._hls.on(Hls.Events.ERROR, this.handleHLSException);
-      this.subscribeStats();
-    } else if (this._videoEl.canPlayType('application/vnd.apple.mpegurl')) {
-      // code for ios safari, mseNot Supported.
-      this._videoEl.src = this._hlsUrl;
-    }
-    this._videoEl.addEventListener('timeupdate', this.handleTimeUpdateListener);
-    this._videoEl.addEventListener('play', this.playEventHandler);
-    this._videoEl.addEventListener('pause', this.pauseEventHandler);
-    this._videoEl.addEventListener('volumechange', this.volumeEventHandler);
-  }
-  /**
-   * 1 min retries before user came online, reason room automatically disconnected if user is offline for more than 1mins
-   * Retries logic will run exponential like (1, 2, 4, 8, 8, 8, 8, 8, 8, 8secs)
-   * there will be total 10 retries
-   */
-  private getPlayerConfig(): Partial<HlsConfig> {
-    return {
-      enableWorker: true,
-      maxBufferLength: 20,
-      backBufferLength: 10,
-      abrBandWidthUpFactor: 1,
-      playlistLoadPolicy: {
-        default: {
-          maxTimeToFirstByteMs: 8000,
-          maxLoadTimeMs: 20000,
-          timeoutRetry: {
-            maxNumRetry: 10,
-            retryDelayMs: 1000,
-            maxRetryDelayMs: 8000,
-            backoff: 'exponential',
-          },
-          errorRetry: {
-            maxNumRetry: 10,
-            retryDelayMs: 1000,
-            maxRetryDelayMs: 8000,
-            backoff: 'exponential',
-          },
-        },
-      },
-    };
-  }
-
-  /**
-   * @param {Array} levels array
-   * @returns a new array with only video levels.
-   */
-  private removeAudioLevels(levels: LevelParsed[]) {
-    return levels.filter(({ videoCodec, width, height }) => !!videoCodec || !!(width && height));
-  }
-
-  /**
-   * @returns true if HLS player is supported in the browser
-   */
-  public static isSupported(): boolean {
-    return Hls.isSupported();
-  }
-}

package/src/controllers/HMSHLSTimedMetadata.ts

@@ -1,119 +0,0 @@
-import Hls, { Fragment } from 'hls.js';
-import { HMSHLSErrorFactory } from '../error/HMSHLSErrorFactory';
-import { HMSHLSPlayerListeners } from '../interfaces/events';
-import { HMSHLSPlayerEvents } from '../utilies/constants';
-import { metadataPayloadParser } from '../utilies/utils';
-
-export class HMSHLSTimedMetadata {
-  private hls: Hls;
-  constructor(
-    hls: Hls,
-    private videoEl: HTMLVideoElement,
-    private emitEvent: <E extends HMSHLSPlayerEvents>(
-      eventName: E,
-      eventObject: Parameters<HMSHLSPlayerListeners<E>>[0],
-    ) => boolean,
-  ) {
-    this.hls = hls;
-    this.registerListner();
-  }
-  extractMetaTextTrack = (): TextTrack | null => {
-    const textTrackListCount = this.videoEl.textTracks.length || 0;
-    for (let trackIndex = 0; trackIndex < textTrackListCount; trackIndex++) {
-      const textTrack = this.videoEl.textTracks[trackIndex];
-      if (textTrack?.kind !== 'metadata') {
-        continue;
-      }
-      textTrack.mode = 'showing';
-      return textTrack;
-    }
-    return null;
-  };
-
-  // sync time with cue and trigger event
-  fireCues = (currentAbsTime: number, tolerance: number) => {
-    const cues = this.extractMetaTextTrack()?.cues;
-    if (!cues) {
-      return;
-    }
-    const cuesLength = cues.length;
-    let cueIndex = 0;
-    while (cueIndex < cuesLength) {
-      const cue = cues[cueIndex] as TextTrackCue & {
-        queued: boolean;
-        value: { data: string };
-      };
-      if (cue.queued) {
-        cueIndex++;
-        continue;
-      }
-      // here we are converting base64 to actual data.
-      const data: Record<string, any> = metadataPayloadParser(cue.value.data);
-      const startDate = data.start_date;
-      const endDate = data.end_date;
-      const timeDiff = new Date(startDate).getTime() - currentAbsTime;
-      const duration = new Date(endDate).getTime() - new Date(startDate).getTime();
-      if (timeDiff <= tolerance) {
-        setTimeout(() => {
-          this.emitEvent(HMSHLSPlayerEvents.TIMED_METADATA_LOADED, {
-            id: cue?.id,
-            payload: data.payload,
-            duration: duration,
-            startDate: new Date(startDate),
-            endDate: new Date(endDate),
-          });
-        }, timeDiff);
-        cue.queued = true;
-      }
-      cueIndex++;
-    }
-  };
-
-  // handle time update listener
-  handleTimeUpdateListener = () => {
-    // extract timed metadata text track
-    const metaTextTrack: TextTrack | null = this.extractMetaTextTrack();
-    if (!metaTextTrack || !metaTextTrack.cues) {
-      return;
-    }
-    // @ts-ignore
-    const firstFragProgramDateTime = this.videoEl?.getStartDate() || 0;
-    const currentAbsTime = new Date(firstFragProgramDateTime).getTime() + (this.videoEl.currentTime || 0) * 1000;
-    // fire cue for timed meta data extract
-    this.fireCues(currentAbsTime, 0.25);
-  };
-  /**
-   * Metadata are automatically parsed and added to the video element's
-   * textTrack cue by hlsjs as they come through the stream.
-   * in FRAG_CHANGED, we read the cues and emitEvent HLS_METADATA_LOADED
-   * when the current fragment has a metadata to play.
-   */
-  fragChangeHandler = (_: any, { frag }: { frag: Fragment }) => {
-    if (!this.videoEl) {
-      const error = HMSHLSErrorFactory.HLSMediaError.videoElementNotFound();
-      this.emitEvent(HMSHLSPlayerEvents.ERROR, error);
-    }
-    try {
-      if (this.videoEl.textTracks.length === 0) {
-        return;
-      }
-      const fragStartTime = frag.programDateTime || 0;
-      const fragmentDuration = frag.end - frag.start;
-      this.fireCues(fragStartTime, fragmentDuration);
-    } catch (e) {
-      console.error('FRAG_CHANGED event error', e);
-    }
-  };
-  private registerListner = () => {
-    if (Hls.isSupported()) {
-      this.hls.on(Hls.Events.FRAG_CHANGED, this.fragChangeHandler);
-    } else if (this.videoEl.canPlayType('application/vnd.apple.mpegurl')) {
-      this.videoEl.addEventListener('timeupdate', this.handleTimeUpdateListener);
-    }
-  };
-
-  unregisterListener = () => {
-    this.hls.off(Hls.Events.FRAG_CHANGED, this.fragChangeHandler);
-    this.videoEl.removeEventListener('timeupdate', this.handleTimeUpdateListener);
-  };
-}

package/src/error/HMSHLSErrorFactory.ts

@@ -1,92 +0,0 @@
-import { HMSHLSException } from './HMSHLSException';
-import { HMSHLSExceptionEvents } from '../utilies/constants';
-
-export type HMSHLSErrorDetails = {
-  details: string;
-  fatal?: boolean;
-};
-export const HMSHLSErrorFactory = {
-  HLSNetworkError: {
-    manifestLoadError(data: HMSHLSErrorDetails): HMSHLSException {
-      return new HMSHLSException(
-        HMSHLSExceptionEvents.MANIFEST_LOAD_ERROR,
-        data.details,
-        'Unable to load manifest file',
-        data.fatal,
-      );
-    },
-    manifestParsingError(data: HMSHLSErrorDetails): HMSHLSException {
-      return new HMSHLSException(
-        HMSHLSExceptionEvents.MANIFEST_PARSING_ERROR,
-        data.details,
-        'Unable to parse manifest file',
-        data.fatal,
-      );
-    },
-    layerLoadError(data: HMSHLSErrorDetails): HMSHLSException {
-      return new HMSHLSException(
-        HMSHLSExceptionEvents.LAYER_LOAD_ERROR,
-        data.details,
-        'Unable to load quality layers',
-        data.fatal,
-      );
-    },
-  },
-  HLSMediaError: {
-    manifestIncompatibleCodecsError(data: HMSHLSErrorDetails): HMSHLSException {
-      return new HMSHLSException(
-        HMSHLSExceptionEvents.MANIFEST_INCOMPATIBLE_CODECS_ERROR,
-        data.details,
-        'Incompatible manifest codecs',
-        data.fatal,
-      );
-    },
-    fragDecryptError(data: HMSHLSErrorDetails): HMSHLSException {
-      return new HMSHLSException(
-        HMSHLSExceptionEvents.FRAG_DECRYPT_ERROR,
-        data.details,
-        'Unable to decrypt fragment',
-        data.fatal,
-      );
-    },
-    bufferIncompatibleCodecsError(data: HMSHLSErrorDetails): HMSHLSException {
-      return new HMSHLSException(
-        HMSHLSExceptionEvents.BUFFER_INCOMPATIBLE_CODECS_ERROR,
-        data.details,
-        'Incompatible buffer codecs',
-        data.fatal,
-      );
-    },
-    videoElementNotFound(): HMSHLSException {
-      return new HMSHLSException(
-        HMSHLSExceptionEvents.VIDEO_ELEMENT_NOT_FOUND,
-        'Video element not found',
-        'Video element not found',
-        false,
-      );
-    },
-    autoplayFailed(): HMSHLSException {
-      return new HMSHLSException(
-        HMSHLSExceptionEvents.HLS_AUTOPLAY_FAILED,
-        'Failed to autoplay',
-        'Failed to autoplay',
-        false,
-      );
-    },
-    hlsURLNotFound(msg?: string): HMSHLSException {
-      return new HMSHLSException(
-        HMSHLSExceptionEvents.HLS_URL_NOT_FOUND,
-        msg || 'hls url not found',
-        msg || 'hls url not found',
-        true,
-      );
-    },
-  },
-  HLSError: (
-    data: HMSHLSErrorDetails,
-    name: string | HMSHLSExceptionEvents = HMSHLSExceptionEvents.HLS_ERROR,
-    description = 'Hls error',
-  ): HMSHLSException => {
-    return new HMSHLSException(name, data.details, description, data.fatal);
-  },
-};

package/src/error/HMSHLSException.ts

@@ -1,38 +0,0 @@
-export class HMSHLSException extends Error {
-  nativeError?: Error;
-
-  constructor(
-    public name: string,
-    public message: string,
-    public description: string,
-    public isTerminal: boolean = false,
-  ) {
-    super(message);
-
-    // Ref: https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
-    Object.setPrototypeOf(this, HMSHLSException.prototype);
-  }
-
-  toAnalyticsProperties() {
-    return {
-      error_name: this.name,
-      error_message: this.message,
-      error_description: this.description,
-      is_terminal: this.isTerminal,
-    };
-  }
-
-  addNativeError(error: Error) {
-    this.nativeError = error;
-  }
-
-  toString() {
-    return `{
-      name: ${this.name};
-      message: ${this.message};
-      description: ${this.description};
-      isTerminal: ${this.isTerminal};
-      nativeError: ${this.nativeError?.message};
-    }`;
-  }
-}

package/src/index.ts

@@ -1,7 +0,0 @@
-import { HlsPlayerStats } from '@100mslive/hls-stats';
-import { HMSHLSPlayer } from './controllers/HMSHLSPlayer';
-import { HMSHLSException } from './error/HMSHLSException';
-import { HMSHLSLayer } from './interfaces/IHMSHLSLayer';
-import { HLSPlaybackState, HMSHLSPlayerEvents } from './utilies/constants';
-export type { HMSHLSLayer, HMSHLSException, HlsPlayerStats };
-export { HMSHLSPlayer, HLSPlaybackState, HMSHLSPlayerEvents };

package/src/interfaces/IHMSHLSLayer.ts

@@ -1,10 +0,0 @@
-import { LevelParsed } from 'hls.js';
-
-export declare interface HMSHLSLayer extends Partial<LevelParsed> {
-  readonly bitrate: number;
-  readonly height?: number;
-  readonly id?: number;
-  readonly width?: number;
-  url: string;
-  resolution?: string;
-}

package/src/interfaces/IHMSHLSPlayer.ts

@@ -1,46 +0,0 @@
-import { HMSHLSLayer } from './IHMSHLSLayer';
-interface IHMSHLSPlayer {
-  /**
-   * @returns get html video element
-   */
-  getVideoElement(): HTMLVideoElement;
-
-  /**
-   * set video volumne
-   * @param { volume } - in range [0,100]
-   */
-  setVolume(volume: number): void;
-  /**
-   *
-   * @returns returns HMSHLSLayer which represents current
-   * quality.
-   */
-  getLayer(): HMSHLSLayer | null;
-  /**
-   *
-   * @param { HMSHLSLayer } layer - layer we want to set the stream to.
-   * set { height: auto } to set the layer to auto
-   */
-  setLayer(layer: HMSHLSLayer): void;
-  /**
-   * move the video to Live
-   */
-  seekToLivePosition(): Promise<void>;
-  /**
-   * play stream
-   * call this when autoplay error is received
-   */
-  play(): Promise<void>;
-  /**
-   * pause stream
-   */
-  pause(): void;
-
-  /**
-   * It will update the video element current time
-   * @param seekValue Pass currentTime in second
-   */
-  seekTo(seekValue: number): void;
-}
-
-export default IHMSHLSPlayer;

package/src/interfaces/events.ts

@@ -1,70 +0,0 @@
-import { HlsPlayerStats } from '@100mslive/hls-stats';
-import { EventEmitter2 as EventEmitter } from 'eventemitter2';
-import { HMSHLSLayer } from './IHMSHLSLayer';
-import { HMSHLSException } from '../error/HMSHLSException';
-import { HLSPlaybackState, HMSHLSPlayerEvents } from '../utilies/constants';
-
-type HMSHLSListenerDataMapping = {
-  [HMSHLSPlayerEvents.SEEK_POS_BEHIND_LIVE_EDGE]: HMSHLSStreamLive;
-  [HMSHLSPlayerEvents.TIMED_METADATA_LOADED]: HMSHLSCue;
-  [HMSHLSPlayerEvents.STATS]: HlsPlayerStats;
-  [HMSHLSPlayerEvents.PLAYBACK_STATE]: HMSHLSPlaybackState;
-  [HMSHLSPlayerEvents.CAPTION_ENABLED]: boolean;
-
-  [HMSHLSPlayerEvents.ERROR]: HMSHLSException;
-  [HMSHLSPlayerEvents.CURRENT_TIME]: number;
-  [HMSHLSPlayerEvents.AUTOPLAY_BLOCKED]: HMSHLSException;
-
-  [HMSHLSPlayerEvents.MANIFEST_LOADED]: HMSHLSManifestLoaded;
-  [HMSHLSPlayerEvents.LAYER_UPDATED]: HMSHLSLayerUpdated;
-};
-
-export type HMSHLSPlayerListeners<E extends HMSHLSPlayerEvents> = (data: HMSHLSListenerDataMapping[E], name: E) => void;
-
-export interface HMSHLSStreamLive {
-  isLive: boolean;
-}
-export interface HMSHLSPlaybackState {
-  state: HLSPlaybackState;
-}
-export interface HMSHLSCue {
-  id?: string;
-  payload: string;
-  duration: number;
-  startDate: Date;
-  endDate?: Date;
-}
-
-export interface HMSHLSManifestLoaded {
-  layers: HMSHLSLayer[];
-}
-export interface HMSHLSLayerUpdated {
-  layer: HMSHLSLayer;
-}
-export interface IHMSHLSPlayerEventEmitter {
-  on<E extends HMSHLSPlayerEvents>(eventName: E, listener: HMSHLSPlayerListeners<E>): void;
-
-  off<E extends HMSHLSPlayerEvents>(eventName: E, listener?: HMSHLSPlayerListeners<E>): void;
-}
-
-export class HMSHLSPlayerEventEmitter implements IHMSHLSPlayerEventEmitter {
-  private eventEmitter: EventEmitter;
-  constructor() {
-    this.eventEmitter = new EventEmitter();
-  }
-  on<E extends HMSHLSPlayerEvents>(eventName: E, listener: HMSHLSPlayerListeners<E>): void {
-    this.eventEmitter.on(eventName, listener);
-  }
-
-  off<E extends HMSHLSPlayerEvents>(eventName: E, listener: HMSHLSPlayerListeners<E>) {
-    this.eventEmitter.off(eventName, listener);
-  }
-
-  emitEvent<E extends HMSHLSPlayerEvents>(eventName: E, eventObject: Parameters<HMSHLSPlayerListeners<E>>[0]): boolean {
-    return this.eventEmitter.emit(eventName, eventObject, eventName);
-  }
-
-  removeAllListeners<E extends HMSHLSPlayerEvents>(eventName?: E): void {
-    this.eventEmitter.removeAllListeners(eventName);
-  }
-}

package/src/utilies/constants.ts

@@ -1,37 +0,0 @@
-export const HLS_DEFAULT_ALLOWED_MAX_LATENCY_DELAY = 5;
-
-export enum HMSHLSPlayerEvents {
-  TIMED_METADATA_LOADED = 'timed-metadata',
-  SEEK_POS_BEHIND_LIVE_EDGE = 'seek-pos-behind-live-edge',
-
-  CURRENT_TIME = 'current-time',
-  AUTOPLAY_BLOCKED = 'autoplay-blocked',
-
-  MANIFEST_LOADED = 'manifest-loaded',
-  LAYER_UPDATED = 'layer-updated',
-  CAPTION_ENABLED = 'caption-enabled',
-
-  ERROR = 'error',
-  PLAYBACK_STATE = 'playback-state',
-  STATS = 'stats',
-}
-
-export enum HMSHLSExceptionEvents {
-  MANIFEST_LOAD_ERROR = 'manifest-load-error',
-  MANIFEST_PARSING_ERROR = 'manifest-parsing-error',
-  LAYER_LOAD_ERROR = 'layer-load-error',
-
-  MANIFEST_INCOMPATIBLE_CODECS_ERROR = 'manifest-incompatible-codecs-error',
-  FRAG_DECRYPT_ERROR = 'frag-decrypt-error',
-  BUFFER_INCOMPATIBLE_CODECS_ERROR = 'buffer-incompatible-codecs-error',
-
-  VIDEO_ELEMENT_NOT_FOUND = 'video-element-not-found',
-  HLS_AUTOPLAY_FAILED = 'hls-autoplay-failed',
-  HLS_URL_NOT_FOUND = 'hls-url-not-found',
-  HLS_ERROR = 'hls-error',
-}
-
-export enum HLSPlaybackState {
-  playing,
-  paused,
-}

package/src/utilies/type.ts

@@ -1,15 +0,0 @@
-import { HMSHLSException } from '../error/HMSHLSException';
-
-declare global {
-  interface Window {
-    __hms:
-      | {
-          sdk:
-            | {
-                sendHLSAnalytics: (error: HMSHLSException) => void;
-              }
-            | undefined;
-        }
-      | undefined;
-  }
-}

package/src/utilies/utils.ts

@@ -1,38 +0,0 @@
-import { Level, LevelParsed } from 'hls.js';
-import { HMSHLSLayer } from '../interfaces/IHMSHLSLayer';
-
-/**
- *
- * @param payload a base64 string coming from backend
- * @returns a parsed data which contains payload, start_date, end_date, version
- */
-export const metadataPayloadParser = (payload: string): Record<string, any> => {
-  try {
-    const data = window?.atob(payload);
-    const parsedData = JSON.parse(data);
-    return parsedData;
-  } catch (e) {
-    return { payload };
-  }
-};
-
-/**
- * map Level[] to HMSHLSLayer[]
- */
-export const mapLayers = (levels: Level[] | LevelParsed[]): HMSHLSLayer[] => {
-  return levels.map((level: Level | LevelParsed) => mapLayer(level));
-};
-
-/**
- * map Level[] to HMSHLSLayer[]
- */
-export const mapLayer = (quality: Level | LevelParsed): HMSHLSLayer => {
-  return {
-    resolution: quality.attrs?.RESOLUTION,
-    bitrate: quality.bitrate,
-    height: quality.height,
-    id: quality.id,
-    url: quality.url[0],
-    width: quality.width,
-  };
-};