chore: update pipelines

packages/playback/src/lib/pipelines/basePipeline.ts

@@ -1,6 +1,17 @@
 import type NetworkManager from '../network/networkManager';
+import type Logger from '../utils/logger';
+
+interface PipelineDependencies {
+  logger: Logger;
+}
 
 export default abstract class Pipeline {
+  private readonly logger: Logger;
+
+  public constructor(dependencies: PipelineDependencies) {
+    this.logger = dependencies.logger;
+  }
+
   protected mapProtocolToNetworkManager = new Map<string, NetworkManager>();
 
   public loadRemoteAsset(uri: URL): void {

packages/playback/src/lib/pipelines/consts/events.ts

@@ -0,0 +1 @@
+export const PipelineEvents = {} as const;

packages/playback/src/lib/pipelines/events/pipelineEventTypeToEventMap.ts

@@ -0,0 +1 @@
+export interface PipelinePlayerEventTypeToEventMap {}

packages/playback/src/lib/player/configuration/configuration.ts

@@ -1,3 +1,24 @@
-export interface PlayerConfiguration {}
+// interface NetworkConfiguration {
+//   maxAttempts: number;
+//   delay: number;
+//   delayFactor: number;
+//   fuzzFactor: number;
+//   timeout: number;
+// }
+//
+// interface StreamingConfiguration {
+//   network: NetworkConfiguration;
+// }
+//
+// interface HlsConfiguration extends StreamingConfiguration {}
+//
+// interface DashConfiguration extends StreamingConfiguration {}
+//
+// export interface PlayerConfiguration {
+//   hls: HlsConfiguration;
+//   dash: DashConfiguration;
+// }
+
+interface PlayerConfiguration {}
 
 export const createDefaultConfiguration = (): PlayerConfiguration => ({});

packages/playback/src/lib/player/events/eventTypeToEventMap.ts → packages/playback/src/lib/player/events/playerEventTypeToEventMap.ts

@@ -8,7 +8,7 @@ import type {
   ErrorEvent,
 } from './playerEvents';
 
-export interface EventTypeToEventMap {
+export interface PlayerEventTypeToEventMap {
   [Events.LoggerLevelChanged]: LoggerLevelChangedEvent;
   [Events.VolumeChanged]: VolumeChangedEvent;
   [Events.MutedStatusChanged]: MutedStatusChangedEvent;

packages/playback/src/lib/player/player.ts

@@ -3,7 +3,6 @@ import Logger, { LoggerLevel } from '../utils/logger';
 import { createDefaultConfiguration } from './configuration/configuration';
 import type { Callback } from '../utils/eventEmitter';
 import EventEmitter from '../utils/eventEmitter';
-import type { EventTypeToEventMap } from './events/eventTypeToEventMap';
 import { Events } from './consts/events';
 import NetworkManager, { RequestType } from '../network/networkManager';
 import type Pipeline from '../pipelines/basePipeline';
@@ -18,6 +17,7 @@ import {
 } from './events/playerEvents';
 import NativePipeline from '../pipelines/native/nativePipeline';
 import { NoSupportedPipelineError } from './errors/pipelinePlayerErrors';
+import type { PlayerEventTypeToEventMap } from './events/playerEventTypeToEventMap';
 
 enum PlaybackState {
   Playing = 'Playing',
@@ -43,7 +43,7 @@ interface PlayerStats {}
 
 interface PlayerDependencies {
   logger: Logger;
-  eventEmitter: EventEmitter<EventTypeToEventMap>;
+  eventEmitter: EventEmitter<PlayerEventTypeToEventMap>;
 }
 
 export default class Player {
@@ -55,8 +55,8 @@ export default class Player {
 
   public static createPlayer(): Player {
     const logger = new Logger(console, 'Player');
-    const networkManager = new NetworkManager(logger);
-    const eventEmitter = new EventEmitter<EventTypeToEventMap>();
+    const networkManager = new NetworkManager({ logger: logger.createSubLogger('NetworkManager') });
+    const eventEmitter = new EventEmitter<PlayerEventTypeToEventMap>();
 
     const player = new Player({ logger, eventEmitter });
     player.registerNetworkManager('http', networkManager);
@@ -66,7 +66,7 @@ export default class Player {
   }
 
   private readonly logger: Logger;
-  private readonly eventEmitter: EventEmitter<EventTypeToEventMap>;
+  private readonly eventEmitter: EventEmitter<PlayerEventTypeToEventMap>;
 
   private videoElement: HTMLVideoElement | null = null;
   private pictureInPictureWindow: PictureInPictureWindow | null = null;
@@ -154,8 +154,6 @@ export default class Player {
       level = volumeLevel;
     }
 
-    // console.log('level: ', level);
-
     return this.safeAttemptOnVideoElement(
       'setVolumeLevel',
       (videoElement) => void (videoElement.volume = level),
@@ -288,25 +286,28 @@ export default class Player {
     this.eventEmitter.emit(Events.LoggerLevelChanged, new LoggerLevelChangedEvent(this.getLoggerLevel()));
   }
 
-  public addEventListener<K extends keyof EventTypeToEventMap>(
+  public addEventListener<K extends keyof PlayerEventTypeToEventMap>(
     event: K,
-    callback: Callback<EventTypeToEventMap[K]>
+    callback: Callback<PlayerEventTypeToEventMap[K]>
   ): void {
     return this.eventEmitter.on(event, callback);
   }
 
-  public once<K extends keyof EventTypeToEventMap>(event: K, callback: Callback<EventTypeToEventMap[K]>): void {
+  public once<K extends keyof PlayerEventTypeToEventMap>(
+    event: K,
+    callback: Callback<PlayerEventTypeToEventMap[K]>
+  ): void {
     return this.eventEmitter.once(event, callback);
   }
 
-  public removeEventListener<K extends keyof EventTypeToEventMap>(
+  public removeEventListener<K extends keyof PlayerEventTypeToEventMap>(
     event: K,
-    callback: Callback<EventTypeToEventMap[K]>
+    callback: Callback<PlayerEventTypeToEventMap[K]>
   ): void {
     return this.eventEmitter.off(event, callback);
   }
 
-  public removeAllEventListenersForType<K extends keyof EventTypeToEventMap>(event: K): void {
+  public removeAllEventListenersForType<K extends keyof PlayerEventTypeToEventMap>(event: K): void {
     return this.eventEmitter.offAllFor(event);
   }
 
@@ -512,7 +513,7 @@ export default class Player {
     let pipeline = this.mimeTypeToPipelineMap.get(mimeType);
 
     if (!pipeline && this.videoElement?.canPlayType(mimeType)) {
-      pipeline = new NativePipeline();
+      pipeline = new NativePipeline({ logger: this.logger.createSubLogger('NativePipeline') });
     }
 
     if (pipeline) {

packages/playback/test/player.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach } from '@jest/globals';
 import { Player } from '../src/player';
 import Logger from '../src/lib/utils/logger';
 import NetworkManager from '../src/lib/network/networkManager';
-import type { EventTypeToEventMap } from '../src/lib/player/events/eventTypeToEventMap';
+import type { PlayerEventTypeToEventMap } from '../src/lib/player/events/PlayerEventTypeToEventMap';
 import EventEmitter from '../src/lib/utils/eventEmitter';
 import { DashPipeline, HlsPipeline } from '../src/lib/pipelines/mse';
 
@@ -12,13 +12,13 @@ describe('Player', () => {
   let videoElement: HTMLVideoElement;
   let dashPipeline: DashPipeline;
   let hlsPipeline: HlsPipeline;
-  let eventEmitter: EventEmitter<EventTypeToEventMap>;
+  let eventEmitter: EventEmitter<PlayerEventTypeToEventMap>;
   let player: Player;
 
   beforeEach(() => {
     logger = new Logger(console, 'Player');
     networkManager = new NetworkManager(logger);
-    eventEmitter = new EventEmitter<EventTypeToEventMap>();
+    eventEmitter = new EventEmitter<PlayerEventTypeToEventMap>();
     videoElement = document.createElement('video');
     dashPipeline = new DashPipeline();
     hlsPipeline = new HlsPipeline();