@100mslive/hls-player 0.0.1-alpha.0

package/src/interfaces/events.ts

@@ -0,0 +1,69 @@
+import { HlsPlayerStats } from '@100mslive/hls-stats';
+import { EventEmitter2 as EventEmitter } from 'eventemitter2';
+import { ILevel } from './ILevel';
+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.ERROR]: HMSHLSException;
+  [HMSHLSPlayerEvents.CURRENT_TIME]: number;
+  [HMSHLSPlayerEvents.AUTOPLAY_BLOCKED]: HMSHLSException;
+
+  [HMSHLSPlayerEvents.MANIFEST_LOADED]: HMSHLSManifestLoaded;
+  [HMSHLSPlayerEvents.LEVEL_UPDATED]: HMSHLSLevelUpdated;
+};
+
+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 {
+  levels: ILevel[];
+}
+export interface HMSHLSLevelUpdated {
+  level: ILevel;
+}
+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);
+  }
+
+  emit<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

@@ -0,0 +1,36 @@
+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',
+  LEVEL_UPDATED = 'level-updated',
+
+  ERROR = 'error',
+  PLAYBACK_STATE = 'playback-state',
+  STATS = 'stats',
+}
+
+export enum HMSHLSExceptionEvents {
+  MANIFEST_LOAD_ERROR = 'manifest-load-error',
+  MANIFEST_PARSING_ERROR = 'manifest-parsing-error',
+  LEVEL_LOAD_ERROR = 'level-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',
+  UNKNOWN_ERROR = 'unknown-error',
+}
+
+export enum HLSPlaybackState {
+  playing,
+  paused,
+}

package/src/utilies/utils.ts

@@ -0,0 +1,38 @@
+import { Level, LevelParsed } from 'hls.js';
+import { ILevel } from '../interfaces/ILevel';
+
+/**
+ *
+ * @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 ILevel[]
+ */
+export const mapLevels = (qualityLevel: Level[] | LevelParsed[]): ILevel[] => {
+  return qualityLevel.map((level: Level | LevelParsed) => mapLevel(level));
+};
+
+/**
+ * map Level[] to ILevel[]
+ */
+export const mapLevel = (qualityLevel: Level | LevelParsed): ILevel => {
+  return {
+    resolution: qualityLevel.attrs?.RESOLUTION,
+    bitrate: qualityLevel.bitrate,
+    height: qualityLevel.height,
+    id: qualityLevel.id,
+    url: qualityLevel.url[0],
+    width: qualityLevel.width,
+  };
+};