Hls preconditions

packages/playback/package.json

@@ -9,6 +9,10 @@
     "test": "bunx jest",
     "test:coverage": "bunx jest --coverage=true"
   },
+  "dependencies": {
+    "@videojs/hls-parser": "*",
+    "@videojs/dash-parser": "*"
+  },
   "exports": {
     "./player": {
       "types": "./dist/player.d.ts",

packages/playback/src/lib/networkManager.ts → packages/playback/src/lib/network/networkManager.ts

@@ -5,10 +5,10 @@ import {
   RequestInterceptorNetworkError,
   ResponseInterceptorNetworkError,
   TimeoutNetworkError,
-} from './errors';
-import type { RetryWrapperOptions } from './utils/retryWrapper';
-import RetryWrapper from './utils/retryWrapper';
-import type Logger from './utils/logger';
+} from './networkManagerErrors';
+import type { RetryWrapperOptions } from '../utils/retryWrapper';
+import RetryWrapper from '../utils/retryWrapper';
+import type Logger from '../utils/logger';
 
 export enum RequestType {
   InitSegment,
@@ -40,14 +40,22 @@ interface NetworkRequestWithProgressiveResponse {
   done: Promise<void>;
 }
 
+interface NetworkManagerDependencies {
+  logger: Logger;
+}
+
 export default class NetworkManager {
+  public static create(dependencies: NetworkManagerDependencies): NetworkManager {
+    return new NetworkManager(dependencies);
+  }
+
   private readonly requestInterceptors = new Map<RequestType, Array<RequestInterceptor>>();
   private readonly responseHandlers = new Map<RequestType, Array<ResponseHandler>>();
 
   private readonly logger: Logger;
 
-  public constructor(logger: Logger) {
-    this.logger = logger.createSubLogger('NetworkManager');
+  public constructor(dependencies: NetworkManagerDependencies) {
+    this.logger = dependencies.logger;
   }
 
   private add<T>(type: RequestType, interceptor: T, interceptors: Map<RequestType, Array<T>>): void {
@@ -160,7 +168,7 @@ export default class NetworkManager {
     headersReceived
       .then((response) => this.applyResponseHandlers(type, response))
       .catch((e) => {
-        this.logger.debug('Error cached from response handlers: ', e);
+        this.logger.debug('Error catched from response handlers: ', e);
       });
 
     return { done, abort };
@@ -205,7 +213,7 @@ export default class NetworkManager {
     headersReceived
       .then((response) => this.applyResponseHandlers(type, response))
       .catch((e) => {
-        this.logger.debug('Error cached from response handlers: ', e);
+        this.logger.debug('Error catched from response handlers: ', e);
       });
 
     return { done, abort };

packages/playback/src/lib/network/networkManagerErrors.ts

@@ -0,0 +1,27 @@
+export class RequestInterceptorNetworkError extends Error {}
+
+export class ResponseInterceptorNetworkError extends Error {}
+
+export class RequestAbortedNetworkError extends Error {}
+
+export class TimeoutNetworkError extends Error {}
+
+export class BadStatusNetworkError extends Error {
+  public readonly response: Response;
+
+  public constructor(response: Response) {
+    super();
+
+    this.response = response;
+  }
+}
+
+export class FetchError extends Error {
+  public readonly fetchError: TypeError;
+
+  public constructor(fetchError: TypeError) {
+    super();
+
+    this.fetchError = fetchError;
+  }
+}

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

@@ -1,4 +1,35 @@
+import type NetworkManager from '../network/networkManager';
+import type Logger from '../utils/logger';
+
+interface PipelineDependencies {
+  logger: Logger;
+}
+
 export default abstract class Pipeline {
-  public abstract loadRemoteAsset(uri: string): void;
+  private readonly logger: Logger;
+
+  public constructor(dependencies: PipelineDependencies) {
+    this.logger = dependencies.logger;
+  }
+
+  protected mapProtocolToNetworkManager = new Map<string, NetworkManager>();
+
+  public loadRemoteAsset(uri: URL): void {
+    const networkManager = this.mapProtocolToNetworkManager.get(uri.protocol);
+
+    if (!networkManager) {
+      // trigger error;
+      return;
+    }
+
+    return this.loadRemoteAssetWithNetworkManager(uri, networkManager);
+  }
+
+  public abstract loadRemoteAssetWithNetworkManager(uri: URL, networkManager: NetworkManager): void;
+
   public abstract loadLocalAsset(asset: string | ArrayBuffer): void;
+
+  public setMapProtocolToNetworkManager(map: Map<string, NetworkManager>): void {
+    this.mapProtocolToNetworkManager = map;
+  }
 }

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/pipelines/mse/dash/dashPipeline.ts

@@ -1,13 +1,26 @@
 import MsePipeLine from '../msePipeline';
+import type NetworkManager from '../../../network/networkManager';
 
 export default class DashPipeline extends MsePipeLine {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public loadLocalAsset(asset: string | ArrayBuffer): void {
-    //TODO
+  public loadRemoteAssetWithNetworkManager(uri: URL, networkManager: NetworkManager): void {
+    // if (this.progressiveParser) {
+    // load and parse progressively
+    // }
+    // if (this.fullPlaylistParser) {
+    // load and parse sequentially
+    // }
+    //trigger error;
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public loadRemoteAsset(uri: string): void {
-    //TODO
+  public loadLocalAsset(asset: string | ArrayBuffer): void {
+    // if (this.fullPlaylistParser) {
+    // just parse
+    // }
+    // if (this.progressiveParser) {
+    // push
+    // }
+    // trigger error;
   }
 }

packages/playback/src/lib/pipelines/mse/hls/hlsPipeline.ts

@@ -1,13 +1,42 @@
+import type { FullPlaylistParser, ProgressiveParser } from '@videojs/hls-parser';
 import MsePipeLine from '../msePipeline';
+import type NetworkManager from '../../../network/networkManager';
 
 export default class HlsPipeline extends MsePipeLine {
+  private progressiveParser: ProgressiveParser | null = null;
+  private fullPlaylistParser: FullPlaylistParser | null = null;
+
+  public setProgressiveParser(parser: ProgressiveParser): void {
+    this.progressiveParser = parser;
+  }
+
+  public setFullPlaylistParser(parser: FullPlaylistParser): void {
+    this.fullPlaylistParser = parser;
+  }
+
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public loadLocalAsset(asset: string | ArrayBuffer): void {
-    //TODO
+  public loadRemoteAssetWithNetworkManager(uri: URL, networkManager: NetworkManager): void {
+    if (this.progressiveParser) {
+      // load and parse progressively
+    }
+
+    if (this.fullPlaylistParser) {
+      // load and parse sequentially
+    }
+
+    //trigger error;
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public loadRemoteAsset(uri: string): void {
-    //TODO
+  public loadLocalAsset(asset: string | ArrayBuffer): void {
+    if (this.fullPlaylistParser) {
+      // just parse
+    }
+
+    if (this.progressiveParser) {
+      // push
+    }
+
+    // trigger error;
   }
 }

packages/playback/src/lib/pipelines/mse/msePipeline.ts

@@ -1,7 +1,8 @@
 import Pipeline from '../basePipeline';
+import type NetworkManager from '../../network/networkManager';
 
 export default abstract class MsePipeLine extends Pipeline {
   public abstract loadLocalAsset(asset: string | ArrayBuffer): void;
 
-  public abstract loadRemoteAsset(uri: string): void;
+  public abstract loadRemoteAssetWithNetworkManager(uri: URL, networkManager: NetworkManager): void;
 }

packages/playback/src/lib/pipelines/native/nativePipeline.ts

@@ -1,4 +1,5 @@
 import Pipeline from '../basePipeline';
+import type NetworkManager from '../../network/networkManager';
 
 export default class NativePipeline extends Pipeline {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -7,7 +8,5 @@ export default class NativePipeline extends Pipeline {
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public loadRemoteAsset(uri: string): void {
-    //TODO
-  }
+  public loadRemoteAssetWithNetworkManager(uri: URL, networkManager: NetworkManager): void {}
 }

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

@@ -0,0 +1,24 @@
+// 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/consts/errors.ts

@@ -0,0 +1,14 @@
+export const ErrorCategory = {
+  Pipeline: 'Pipeline',
+  Network: 'Network',
+} as const;
+
+export const PipelineErrorCodes = {
+  NoSupportedPipeline: 'NoSupportedPipeline',
+} as const;
+
+export const NetworkErrorCodes = {
+  NoNetworkManagerRegisteredForProtocol: 'NoNetworkManagerRegisteredForProtocol',
+} as const;
+
+export type ErrorCode = keyof typeof PipelineErrorCodes | keyof typeof NetworkErrorCodes;