@mediafox/core 1.2.8 → 1.2.10

package/src/mediafox.ts

@@ -0,0 +1,642 @@
+import { PlayerCore } from './core/player-core';
+import { StateFacade } from './core/state-facade';
+import { TrackSwitcher } from './core/track-switcher';
+import { EventEmitter } from './events/emitter';
+import type { UnsubscribeFn } from './events/types';
+import { PlaybackController } from './playback/controller';
+import { RendererFactory } from './playback/renderers';
+import { PlaylistManager } from './playlist/manager';
+import { PluginManager } from './plugins/manager';
+import type { MediaFoxPlugin } from './plugins/types';
+import { SourceManager } from './sources/manager';
+import { Store } from './state/store';
+import { TrackManager } from './tracks/manager';
+import type { SubtitleTrackRegistration, SubtitleTrackResource } from './tracks/types';
+import type {
+  AudioTrackInfo,
+  LoadOptions,
+  MediaSource,
+  PlayerEventListener,
+  PlayerEventMap,
+  PlayerOptions,
+  PlayerStateData,
+  PlaylistItem,
+  PlaylistMode,
+  RendererType,
+  Rotation,
+  ScreenshotOptions,
+  SeekOptions,
+  Subscription,
+  SubtitleTrackInfo,
+  VideoTrackInfo,
+} from './types';
+//
+
+export class MediaFox {
+  private emitter: EventEmitter<PlayerEventMap>;
+  private store: Store;
+  private state: StateFacade;
+  private sourceManager: SourceManager;
+  private playbackController: PlaybackController;
+  private trackManager: TrackManager;
+  private playlistManager: PlaylistManager;
+  private pluginManager: PluginManager;
+  private options: PlayerOptions;
+  private disposed = false;
+  private getCurrentInput = () => this.sourceManager.getCurrentSource()?.input ?? null;
+  private trackSwitcher: TrackSwitcher;
+  private core: PlayerCore;
+
+  constructor(options: PlayerOptions = {}) {
+    this.options = {
+      volume: 1,
+      muted: false,
+      playbackRate: 1,
+      autoplay: false,
+      preload: 'metadata',
+      ...options,
+    };
+
+    // Initialize components
+    this.emitter = new EventEmitter({ maxListeners: 100 });
+    this.store = new Store();
+    this.state = new StateFacade(this.store);
+    this.sourceManager = new SourceManager({
+      maxCacheSize: options.maxCacheSize,
+      crossOrigin: options.crossOrigin,
+    });
+    this.playbackController = new PlaybackController({
+      canvas: options.renderTarget,
+      audioContext: options.audioContext,
+      volume: this.options.volume,
+      muted: this.options.muted,
+      playbackRate: this.options.playbackRate,
+      rendererType: this.options.renderer,
+    });
+    this.trackManager = new TrackManager();
+    this.playlistManager = new PlaylistManager(
+      this.store,
+      this.emitter,
+      async (item, autoplay) => {
+        await this.core.load(item.mediaSource, {
+          startTime: item.savedPosition ?? 0,
+          autoplay,
+          playlistItemId: item.id,
+        });
+      },
+      this.sourceManager
+    );
+
+    this.trackSwitcher = new TrackSwitcher({
+      sourceManager: this.sourceManager,
+      trackManager: this.trackManager,
+      playbackController: this.playbackController,
+      emit: this.emit.bind(this),
+      store: this.store,
+      getCurrentInput: this.getCurrentInput,
+    });
+
+    // Initialize plugin manager
+    this.pluginManager = new PluginManager(this);
+
+    this.core = new PlayerCore({
+      state: this.state,
+      sourceManager: this.sourceManager,
+      trackManager: this.trackManager,
+      playbackController: this.playbackController,
+      trackSwitcher: this.trackSwitcher,
+      emit: this.emit.bind(this),
+      pluginManager: this.pluginManager,
+    });
+
+    // Pass plugin manager to components that need it
+    this.playbackController.setPluginManager(this.pluginManager);
+    this.store.setPluginManager(this.pluginManager);
+
+    // Setup internal listeners
+    this.setupInternalListeners();
+
+    // Apply initial state
+    this.state.applyInitial(this.options.volume ?? 1, this.options.muted ?? false, this.options.playbackRate ?? 1);
+
+    // Initialize renderer type in state to requested type (default to webgpu)
+    // The actual renderer type will be updated when initialization completes
+    this.state.updateRendererType(this.options.renderer || 'webgpu');
+  }
+
+  private setupInternalListeners(): void {
+    // Playback controller listeners
+    this.playbackController.setTimeUpdateCallback((time) => {
+      this.state.updateTime(time);
+      this.emit('timeupdate', { currentTime: time });
+    });
+
+    this.playbackController.setEndedCallback(() => {
+      this.state.updateEndedState(true);
+      this.emit('ended', undefined);
+      const state = this.getState();
+
+      // Handle playlist modes that auto-advance or repeat
+      if (state.playlist.length > 0 && state.currentPlaylistIndex !== null) {
+        const mode = state.playlistMode;
+        const currentIndex = state.currentPlaylistIndex;
+
+        if (mode === 'repeat-one') {
+          // Restart current item
+          const targetIndex = currentIndex;
+          queueMicrotask(async () => {
+            try {
+              await this.seek(0);
+              await this.play();
+            } catch (error) {
+              this.emitter.emit('playlistitemerror', { index: targetIndex, error: error as Error });
+            }
+          });
+        } else if (mode === 'repeat') {
+          // Advance to next, loop to start if at end
+          const targetIndex = currentIndex < state.playlist.length - 1 ? currentIndex + 1 : 0;
+          queueMicrotask(async () => {
+            try {
+              await this.playlistManager.next();
+            } catch (error) {
+              this.emitter.emit('playlistitemerror', { index: targetIndex, error: error as Error });
+            }
+          });
+        } else if (mode === 'sequential' && currentIndex < state.playlist.length - 1) {
+          // Advance to next if not at end
+          const targetIndex = currentIndex + 1;
+          queueMicrotask(async () => {
+            try {
+              await this.playlistManager.next();
+            } catch (error) {
+              this.emitter.emit('playlistitemerror', { index: targetIndex, error: error as Error });
+            }
+          });
+        }
+      }
+    });
+
+    // Track manager listeners
+    this.trackManager.setTrackChangeListener((event) => {
+      this.state.updateSelectedTracks(event.type, event.newTrackId);
+      this.emit('trackchange', {
+        type: event.type,
+        trackId: event.newTrackId,
+      });
+    });
+
+    // Waiting/buffering callbacks
+    this.playbackController.setWaitingCallback(() => {
+      this.state.updateWaitingState(true);
+      this.emit('waiting', undefined);
+    });
+
+    this.playbackController.setPlayingCallback(() => {
+      const state = this.getState();
+      if (state.waiting) {
+        this.state.updateWaitingState(false);
+        this.emit('playing', undefined);
+      }
+    });
+
+    // Renderer callbacks
+    this.playbackController.setRendererChangeCallback((type) => {
+      this.state.updateRendererType(type);
+      this.emit('rendererchange', type);
+    });
+
+    this.playbackController.setRendererFallbackCallback((from, to) => {
+      this.emit('rendererfallback', { from, to });
+    });
+
+    // Rotation callback
+    this.playbackController.setRotationChangeCallback((rotation, displaySize) => {
+      this.store.updateRotation(rotation, displaySize);
+      this.emit('rotationchange', { rotation, displaySize });
+    });
+
+    // State change listener
+    this.state.subscribe((state) => {
+      this.emit('statechange', state);
+    });
+  }
+
+  // Main API Methods
+
+  /**
+   * Load a media source and prepare playback.
+   * Emits: loadstart, loadedmetadata, loadeddata, canplay, canplaythrough (or error)
+   */
+  async load(source: MediaSource, options: LoadOptions & { replacePlaylist?: boolean } = {}): Promise<void> {
+    this.checkDisposed();
+    const state = this.getState();
+
+    if (state.playlist.length === 0 || options.replacePlaylist) {
+      await this.playlistManager.loadPlaylist([{ mediaSource: source }], {
+        autoplay: options.autoplay ?? this.options.autoplay,
+        startTime: options.startTime,
+      });
+      return;
+    } else if (state.currentPlaylistIndex !== null && state.playlist.length > 0) {
+      // Replace current item
+      const currentIndex = state.currentPlaylistIndex;
+      const oldItem = state.playlist[currentIndex];
+      const newItem: PlaylistItem = {
+        ...oldItem,
+        mediaSource: source,
+        savedPosition: 0, // Reset for new source
+        duration: null,
+      };
+      const newPlaylist = [...state.playlist];
+      newPlaylist[currentIndex] = newItem;
+      this.store.updatePlaylist(newPlaylist, currentIndex);
+      this.emitter.emit('playlistchange', { playlist: newPlaylist });
+
+      // Load the new source
+      await this.core.load(source, {
+        startTime: options.startTime ?? 0,
+        autoplay: options.autoplay ?? this.options.autoplay,
+      });
+      return;
+    }
+
+    // Fallback for no playlist logic
+    await this.core.load(source, {
+      autoplay: options.autoplay ?? this.options.autoplay,
+      startTime: options.startTime,
+    });
+  }
+
+  /** Start playback. */
+  async play(): Promise<void> {
+    this.checkDisposed();
+    return this.core.play();
+  }
+
+  pause(): void {
+    this.checkDisposed();
+    this.core.pause();
+  }
+
+  /** Seek to a new time (seconds). */
+  async seek(time: number, _options: SeekOptions = {}): Promise<void> {
+    this.checkDisposed();
+    return this.core.seek(time);
+  }
+
+  /** Pause and reset to time 0. */
+  async stop(): Promise<void> {
+    this.checkDisposed();
+    return this.core.stop();
+  }
+
+  // Property getters/setters
+
+  get currentTime(): number {
+    return this.playbackController.getCurrentTime();
+  }
+
+  /**
+   * Sets the current playback time. Note: This is a fire-and-forget operation.
+   * Use seek() directly if you need to await the operation.
+   */
+  set currentTime(time: number) {
+    this.seek(time);
+  }
+
+  get duration(): number {
+    return this.state.getState().duration;
+  }
+
+  get volume(): number {
+    return this.playbackController.getVolume();
+  }
+
+  set volume(value: number) {
+    this.checkDisposed();
+    const volume = Math.max(0, Math.min(1, value));
+    this.playbackController.setVolume(volume);
+    this.state.updateVolume(volume, this.muted);
+    this.emit('volumechange', { volume, muted: this.muted });
+  }
+
+  get muted(): boolean {
+    return this.playbackController.isMuted();
+  }
+
+  set muted(value: boolean) {
+    this.checkDisposed();
+    this.playbackController.setMuted(value);
+    this.state.updateVolume(this.volume, value);
+    this.emit('volumechange', { volume: this.volume, muted: value });
+  }
+
+  get playbackRate(): number {
+    return this.playbackController.getPlaybackRate();
+  }
+
+  set playbackRate(value: number) {
+    this.checkDisposed();
+    const rate = Math.max(0.25, Math.min(4, value));
+    this.playbackController.setPlaybackRate(rate);
+    this.state.updatePlaybackRate(rate);
+    this.emit('ratechange', { playbackRate: rate });
+  }
+
+  get paused(): boolean {
+    return !this.playbackController.isPlaying();
+  }
+
+  get ended(): boolean {
+    return this.state.getState().ended;
+  }
+
+  get seeking(): boolean {
+    return this.state.getState().seeking;
+  }
+
+  get waiting(): boolean {
+    return this.state.getState().waiting;
+  }
+
+  // Rotation control
+
+  get rotation(): Rotation {
+    return this.playbackController.getRotation();
+  }
+
+  set rotation(value: Rotation) {
+    this.checkDisposed();
+    this.playbackController.setRotation(value);
+  }
+
+  get displaySize(): { width: number; height: number } {
+    return this.playbackController.getDisplaySize();
+  }
+
+  // Track management
+
+  getVideoTracks(): VideoTrackInfo[] {
+    return this.trackManager.getVideoTracks();
+  }
+
+  getAudioTracks(): AudioTrackInfo[] {
+    return this.trackManager.getAudioTracks();
+  }
+
+  getSubtitleTracks(): SubtitleTrackInfo[] {
+    return this.trackManager.getSubtitleTracks();
+  }
+
+  async selectVideoTrack(trackId: string | null): Promise<void> {
+    this.checkDisposed();
+    await this.trackSwitcher.selectVideoTrack(this.trackManager, trackId);
+  }
+
+  async selectAudioTrack(trackId: string | null): Promise<void> {
+    this.checkDisposed();
+    await this.trackSwitcher.selectAudioTrack(this.trackManager, trackId);
+  }
+
+  selectSubtitleTrack(trackId: string | null): void {
+    this.checkDisposed();
+
+    if (!this.trackManager.selectSubtitleTrack(trackId)) {
+      throw new Error(`Invalid subtitle track ID: ${trackId}`);
+    }
+  }
+
+  registerSubtitleTracks(sourceId: string, registrations: SubtitleTrackRegistration[]): void {
+    this.trackManager.registerSubtitleTracks(sourceId, registrations);
+    this.state.updateTracks(undefined, undefined, this.trackManager.getSubtitleTracks());
+
+    const currentInfo = this.state.getState().mediaInfo;
+    if (currentInfo) {
+      this.state.updateMediaInfo({
+        ...currentInfo,
+        hasSubtitles: this.trackManager.hasSubtitles(),
+      });
+    }
+  }
+
+  unregisterSubtitleTracks(sourceId: string): void {
+    this.trackManager.unregisterSubtitleTracks(sourceId);
+    this.state.updateTracks(undefined, undefined, this.trackManager.getSubtitleTracks());
+
+    const currentInfo = this.state.getState().mediaInfo;
+    if (currentInfo) {
+      this.state.updateMediaInfo({
+        ...currentInfo,
+        hasSubtitles: this.trackManager.hasSubtitles(),
+      });
+    }
+  }
+
+  async getSubtitleTrackResource(trackId: string | null): Promise<SubtitleTrackResource | null> {
+    return this.trackManager.getSubtitleTrackResource(trackId);
+  }
+
+  // Utility methods
+
+  /** Capture a screenshot of the current frame. */
+  async screenshot(options: ScreenshotOptions = {}): Promise<Blob | null> {
+    this.checkDisposed();
+    return this.playbackController.screenshot(options);
+  }
+
+  async setRenderTarget(canvas: HTMLCanvasElement | OffscreenCanvas): Promise<void> {
+    this.checkDisposed();
+    await this.playbackController.setCanvas(canvas);
+  }
+
+  getRenderTarget(): HTMLCanvasElement | OffscreenCanvas | null {
+    return this.playbackController.getCanvas();
+  }
+
+  /** @internal Refresh plugin overlays immediately */
+  refreshOverlays(): void {
+    this.playbackController.refreshOverlays();
+  }
+
+  // Playlist API
+  async loadPlaylist(
+    items: Array<MediaSource | { mediaSource: MediaSource; title?: string; poster?: string }>,
+    options?: { autoplay?: boolean; startTime?: number }
+  ): Promise<void> {
+    this.checkDisposed();
+    await this.playlistManager.loadPlaylist(items, options);
+  }
+
+  addToPlaylist(
+    item: MediaSource | { mediaSource: MediaSource; title?: string; poster?: string },
+    index?: number
+  ): void {
+    this.checkDisposed();
+    this.playlistManager.addToPlaylist(item, index);
+  }
+
+  async removeFromPlaylist(index: number): Promise<void> {
+    this.checkDisposed();
+    await this.playlistManager.removeFromPlaylist(index);
+  }
+
+  clearPlaylist(): void {
+    this.checkDisposed();
+    this.playlistManager.clearPlaylist();
+  }
+
+  async next(): Promise<void> {
+    this.checkDisposed();
+    await this.playlistManager.next();
+  }
+
+  async prev(): Promise<void> {
+    this.checkDisposed();
+    await this.playlistManager.prev();
+  }
+
+  async jumpTo(index: number): Promise<void> {
+    this.checkDisposed();
+    await this.playlistManager.jumpTo(index);
+  }
+
+  get playlist() {
+    return this.playlistManager.playlist;
+  }
+
+  get playlistIndex() {
+    return this.playlistManager.currentIndex;
+  }
+
+  get nowPlaying() {
+    return this.playlistManager.currentItem;
+  }
+
+  get playlistMode() {
+    return this.playlistManager.mode;
+  }
+
+  set playlistMode(mode: PlaylistMode) {
+    this.checkDisposed();
+    this.playlistManager.setMode(mode);
+  }
+
+  getRendererType(): RendererType {
+    return this.playbackController.getRendererType();
+  }
+
+  async switchRenderer(type: RendererType): Promise<void> {
+    this.checkDisposed();
+    await this.playbackController.switchRenderer(type);
+  }
+
+  /**
+   * Updates canvas backing buffer to match its CSS display size.
+   * Call this after changing CSS dimensions to prevent stretching.
+   */
+  updateCanvasDimensions(): void {
+    this.checkDisposed();
+    this.playbackController.updateCanvasDimensions();
+  }
+
+  static getSupportedRenderers(): RendererType[] {
+    return RendererFactory.getSupportedRenderers();
+  }
+
+  getState(): Readonly<PlayerStateData> {
+    return this.state.getState();
+  }
+
+  /** Subscribe to state changes; returns an unsubscribe handle. */
+  subscribe(listener: (state: PlayerStateData) => void): Subscription {
+    const unsubscribe = this.state.subscribe(listener);
+    return { unsubscribe };
+  }
+
+  // Event handling
+
+  on<K extends keyof PlayerEventMap>(event: K, listener: PlayerEventListener<K>): UnsubscribeFn {
+    return this.emitter.on(event, listener);
+  }
+
+  once<K extends keyof PlayerEventMap>(event: K, listener: PlayerEventListener<K>): UnsubscribeFn {
+    return this.emitter.once(event, listener);
+  }
+
+  off<K extends keyof PlayerEventMap>(event: K, listener?: PlayerEventListener<K>): void {
+    this.emitter.off(event, listener);
+  }
+
+  // Plugin API
+
+  /**
+   * Install a plugin.
+   * @param plugin The plugin to install
+   */
+  async use(plugin: MediaFoxPlugin): Promise<void> {
+    this.checkDisposed();
+    await this.pluginManager.install(plugin);
+
+    // Rebuild audio graph if plugin has audio hooks
+    if (plugin.hooks?.audio) {
+      this.playbackController.rebuildAudioGraph();
+    }
+  }
+
+  /**
+   * Uninstall a plugin by name.
+   * @param name The name of the plugin to uninstall
+   */
+  async unuse(name: string): Promise<void> {
+    this.checkDisposed();
+    await this.pluginManager.uninstall(name);
+
+    // Always rebuild audio graph after uninstalling (cheaper than checking)
+    this.playbackController.rebuildAudioGraph();
+  }
+
+  private emit<K extends keyof PlayerEventMap>(event: K, data: PlayerEventMap[K]): void {
+    // Execute beforeEvent hooks
+    const result = this.pluginManager.executeBeforeEvent(event, data);
+    if (result?.cancel) return;
+
+    // Use modified data if provided
+    const finalData = result?.data ?? data;
+
+    // Emit the event
+    this.emitter.emit(event, finalData);
+
+    // Execute afterEvent hooks
+    this.pluginManager.executeAfterEvent(event, finalData);
+  }
+
+  private checkDisposed(): void {
+    if (this.disposed) {
+      throw new Error('Player has been disposed');
+    }
+  }
+
+  // Cleanup
+
+  dispose(): void {
+    if (this.disposed) return;
+
+    this.disposed = true;
+
+    // Dispose plugins first
+    void this.pluginManager.dispose();
+
+    // Dispose components
+    this.playbackController.dispose();
+    this.trackManager.dispose();
+    this.playlistManager?.dispose(); // If manager has dispose
+    this.sourceManager.dispose();
+    this.state.reset();
+    this.emitter.removeAllListeners();
+  }
+
+  destroy(): void {
+    this.dispose();
+    this.playbackController.destroy();
+  }
+}