chore: add default config for worker

packages/playback/src/lib/configuration/configuration-defaults.ts

@@ -0,0 +1,27 @@
+import type {
+  NetworkConfiguration,
+  PlayerConfiguration,
+  PlayerNetworkConfiguration,
+} from '../types/configuration.declarations';
+import { RequestType } from '../consts/request-type';
+
+export const getNetworkConfigurationDefaults = (): NetworkConfiguration => ({
+  maxAttempts: 2,
+  initialDelay: 2_000,
+  delayFactor: 0.2,
+  fuzzFactor: 0.2,
+  timeout: 20_000,
+});
+
+export const getPlayerNetworkConfigurationDefaults = (): PlayerNetworkConfiguration => ({
+  [RequestType.DashManifest]: getNetworkConfigurationDefaults(),
+  [RequestType.HlsPlaylist]: getNetworkConfigurationDefaults(),
+  [RequestType.License]: getNetworkConfigurationDefaults(),
+  [RequestType.Key]: getNetworkConfigurationDefaults(),
+  [RequestType.InitSegment]: getNetworkConfigurationDefaults(),
+  [RequestType.MediaSegment]: getNetworkConfigurationDefaults(),
+});
+
+export const getPlayerConfigurationDefaults = (): PlayerConfiguration => ({
+  network: getPlayerNetworkConfigurationDefaults(),
+});

packages/playback/src/lib/configuration/configurationNodes/player-network-configuration-node.ts

@@ -1,16 +1,11 @@
 import { StoreNode } from '../../utils/store';
 import type { NetworkConfiguration, PlayerNetworkConfiguration } from '../../types/configuration.declarations';
 import { RequestType } from '../../consts/request-type';
+import { getNetworkConfigurationDefaults } from '../configuration-defaults';
 
 class NetworkConfigurationImpl extends StoreNode<NetworkConfiguration> {
   public static default(): NetworkConfigurationImpl {
-    return new NetworkConfigurationImpl({
-      maxAttempts: 2,
-      initialDelay: 2_000,
-      delayFactor: 0.2,
-      fuzzFactor: 0.2,
-      timeout: 20_000,
-    });
+    return new NetworkConfigurationImpl(getNetworkConfigurationDefaults());
   }
 }
 

packages/playback/src/lib/player/worker-thread/worker-bridge.ts

@@ -2,42 +2,67 @@
  * This file should be entry point for worker bundle
  */
 import type { WorkerToMainMessage } from './messages/worker-to-main-messages';
-import type { MainToWorkerMessage } from './messages/main-to-worker-messages';
+import type {
+  MainToWorkerMessage,
+  SetLoggerLevelMessage,
+  UpdateConfigurationMessage,
+} from './messages/main-to-worker-messages';
 import { MainToWorkerMessageType } from './consts/main-to-worker-message-type';
+import type { ILogger } from '../../types/logger.declarations';
+import type { PlayerConfiguration } from '../../types/configuration.declarations';
+// services:
+import { Logger } from '../../utils/logger';
+import { getPlayerConfigurationDefaults } from '../../configuration/configuration-defaults';
 
 interface WorkerBridgeDependencies {
   readonly globalScope: Window & typeof globalThis;
+  readonly logger: ILogger;
+  readonly configuration: PlayerConfiguration;
 }
 
 class WorkerBridge {
   public static create(): WorkerBridge {
     return new WorkerBridge({
       globalScope: self,
+      logger: new Logger({ console: console, delimiter: '>', label: 'Player' }).createSubLogger('WorkerBridge'),
+      configuration: getPlayerConfigurationDefaults(),
     });
   }
 
+  private readonly logger_: ILogger;
   private readonly globalScope_: Window & typeof globalThis;
 
+  private configuration_: PlayerConfiguration;
+
   public constructor(dependencies: WorkerBridgeDependencies) {
     this.globalScope_ = dependencies.globalScope;
+    this.logger_ = dependencies.logger;
+    this.configuration_ = dependencies.configuration;
+
     // We don't care about clean-up, since terminate() call on main thread should fully destroy worker
     this.globalScope_.addEventListener('message', this.onMessageFromMainThread_);
   }
 
   private readonly onMessageFromMainThread_ = (event: MessageEvent<MainToWorkerMessage>): void => {
     switch (event.data.type) {
-      case MainToWorkerMessageType.SetLoggerLevel: {
-        break;
-      }
-      case MainToWorkerMessageType.UpdateConfiguration: {
-        break;
-      }
+      case MainToWorkerMessageType.SetLoggerLevel:
+        return this.handleSetLoggerLevelMessage_(event.data as SetLoggerLevelMessage);
+      case MainToWorkerMessageType.UpdateConfiguration:
+        return this.handleUpdateConfigurationMessage_(event.data as UpdateConfigurationMessage);
       default: {
         break;
       }
     }
   };
 
+  private handleSetLoggerLevelMessage_(message: SetLoggerLevelMessage): void {
+    this.logger_.setLoggerLevel(message.level);
+  }
+
+  private handleUpdateConfigurationMessage_(message: UpdateConfigurationMessage): void {
+    this.configuration_ = message.configuration;
+  }
+
   private sendMessageToMainThread_(message: WorkerToMainMessage): void {
     this.globalScope_.postMessage(message);
   }

packages/playback/test/player.test.ts

@@ -1,6 +1,5 @@
 import { beforeEach, describe, expect, it } from 'vitest';
 import { Player } from '../src/lib/player';
-import type { PlayerConfiguration } from '../src/lib/types/configuration.declarations';
 import {
   ConfigurationChangedEvent,
   LoggerLevelChangedEvent,
@@ -9,55 +8,7 @@ import {
 import type { PlayerEvent } from '../src/lib/events/base-player-event';
 import { RequestType } from '../src/lib/consts/request-type';
 import { ServiceLocator } from '../src/lib/service-locator';
-// import type { ILogger } from '../src/lib/types/logger';
-// import { instance, mock, verify, when } from '@typestrong/ts-mockito';
-
-const createPlayerDefaultConfiguration = (): PlayerConfiguration => ({
-  network: {
-    [RequestType.DashManifest]: {
-      maxAttempts: 2,
-      initialDelay: 2_000,
-      delayFactor: 0.2,
-      fuzzFactor: 0.2,
-      timeout: 20_000,
-    },
-    [RequestType.HlsPlaylist]: {
-      maxAttempts: 2,
-      initialDelay: 2_000,
-      delayFactor: 0.2,
-      fuzzFactor: 0.2,
-      timeout: 20_000,
-    },
-    [RequestType.Key]: {
-      maxAttempts: 2,
-      initialDelay: 2_000,
-      delayFactor: 0.2,
-      fuzzFactor: 0.2,
-      timeout: 20_000,
-    },
-    [RequestType.MediaSegment]: {
-      maxAttempts: 2,
-      initialDelay: 2_000,
-      delayFactor: 0.2,
-      fuzzFactor: 0.2,
-      timeout: 20_000,
-    },
-    [RequestType.InitSegment]: {
-      maxAttempts: 2,
-      initialDelay: 2_000,
-      delayFactor: 0.2,
-      fuzzFactor: 0.2,
-      timeout: 20_000,
-    },
-    [RequestType.License]: {
-      maxAttempts: 2,
-      initialDelay: 2_000,
-      delayFactor: 0.2,
-      fuzzFactor: 0.2,
-      timeout: 20_000,
-    },
-  },
-});
+import { getPlayerConfigurationDefaults } from '../src/lib/configuration/configuration-defaults';
 
 describe('Player spec', () => {
   let player: Player;
@@ -104,8 +55,8 @@ describe('Player spec', () => {
       const snapshot1 = player.getConfigurationSnapshot();
       const snapshot2 = player.getConfigurationSnapshot();
 
-      expect(snapshot1).toEqual(createPlayerDefaultConfiguration());
-      expect(snapshot2).toEqual(createPlayerDefaultConfiguration());
+      expect(snapshot1).toEqual(getPlayerConfigurationDefaults());
+      expect(snapshot2).toEqual(getPlayerConfigurationDefaults());
       expect(snapshot1).not.toBe(snapshot2);
     });
   });