@editframe/elements 0.18.3-beta.0 → 0.18.8-beta.0

package/dist/DecoderResetFrequency.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/DecoderResetRecovery.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/ScrubTrackManager.d.ts

@@ -1,96 +0,0 @@
-export interface ScrubTrackConfig {
-    maxScrubCacheSegments?: number;
-    prefetchCount?: number;
-    fastSeekThresholdMs?: number;
-    onLoadingStateChange?: (isLoading: boolean, message?: string) => void;
-}
-export interface CacheStats {
-    hits: number;
-    misses: number;
-    hitRate: number;
-}
-export declare class ScrubTrackManager {
-    readonly videoUrl: string;
-    private jitClient;
-    private config;
-    private scrubCache;
-    private metadata;
-    private cacheHits;
-    private cacheMisses;
-    private isInitialized;
-    private preloadingSegments;
-    constructor(videoUrl: string, jitClient: any, // JitTranscodingClient,
-    config?: ScrubTrackConfig);
-    /**
-     * Initialize scrub track manager and start preloading
-     */
-    initialize(): Promise<void>;
-    /**
-     * Determine if scrub track should be used instead of normal video
-     */
-    shouldUseScrubTrack(seekTimeMs: number): boolean;
-    /**
-     * Detect if this is a fast seeking operation
-     */
-    isFastSeeking(currentTimeMs: number, seekTimeMs: number): boolean;
-    /**
-     * Align seek time to 30s scrub segment boundary
-     */
-    alignToScrubBoundary(timeMs: number): number;
-    /**
-     * Get scrub frame for the given seek time
-     */
-    getScrubFrame(seekTimeMs: number): Promise<VideoFrame | null>;
-    /**
-     * Record cache hit for statistics
-     */
-    recordCacheHit(): void;
-    /**
-     * Record cache miss for statistics
-     */
-    recordCacheMiss(): void;
-    /**
-     * Get cache performance statistics
-     */
-    getCacheStats(): CacheStats;
-    /**
-     * Check if scrub segment is cached for the given time
-     */
-    isScrubSegmentCached(seekTimeMs: number): boolean;
-    /**
-     * Get current scrub cache size
-     */
-    getScrubCacheSize(): number;
-    /**
-     * Get total number of scrub segments for video
-     */
-    getTotalScrubSegments(): number;
-    /**
-     * Update metadata (e.g., when video duration changes)
-     */
-    updateMetadata(): Promise<void>;
-    /**
-     * Preload initial scrub segments
-     */
-    private preloadInitialSegments;
-    /**
-     * Preload nearby segments around a given time
-     */
-    private preloadNearbySegments;
-    /**
-     * Preload a single scrub segment (background operation)
-     */
-    private preloadSegment;
-    /**
-     * Cache a scrub segment with LRU eviction
-     */
-    private cacheSegment;
-    /**
-     * Clear cache and reset state
-     */
-    reset(): void;
-    /**
-     * Clean up resources and cancel any pending operations
-     */
-    cleanup(): void;
-}

package/dist/elements/EFMedia/services/AudioElementFactory.browsertest.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/elements/EFMedia/services/AudioElementFactory.d.ts

@@ -1,22 +0,0 @@
-import { MediaSourceService } from './MediaSourceService.js';
-/**
- * Factory for creating and caching MediaElementAudioSourceNode instances
- * Handles the complex lifecycle and caching logic previously embedded in EFMedia
- */
-export declare class AudioElementFactory {
-    private cache;
-    private currentSource;
-    private currentAudioContext;
-    /**
-     * Create or retrieve cached MediaElementAudioSourceNode for the given AudioContext
-     */
-    createMediaElementSource(audioContext: AudioContext, mediaSourceService: MediaSourceService): Promise<MediaElementAudioSourceNode>;
-    /**
-     * Clear all cached sources (useful for testing or cleanup)
-     */
-    clearCache(): void;
-    /**
-     * Check if we have a cached source for the given AudioContext
-     */
-    hasCachedSource(audioContext: AudioContext): boolean;
-}

package/dist/elements/EFMedia/services/AudioElementFactory.js

@@ -1,72 +0,0 @@
-/**
-* Factory for creating and caching MediaElementAudioSourceNode instances
-* Handles the complex lifecycle and caching logic previously embedded in EFMedia
-*/
-var AudioElementFactory = class {
-	constructor() {
-		this.cache = /* @__PURE__ */ new WeakMap();
-		this.currentSource = null;
-		this.currentAudioContext = null;
-	}
-	/**
-	* Create or retrieve cached MediaElementAudioSourceNode for the given AudioContext
-	*/
-	async createMediaElementSource(audioContext, mediaSourceService) {
-		const cached = this.cache.get(audioContext);
-		if (cached && audioContext.state !== "closed" && this.currentAudioContext === audioContext) return cached;
-		if (this.currentSource && this.currentAudioContext !== audioContext) {
-			this.currentSource.disconnect();
-			if (this.currentAudioContext) this.cache.delete(this.currentAudioContext);
-			this.currentSource = null;
-			this.currentAudioContext = null;
-		}
-		await mediaSourceService.ensureInitialized();
-		const audioElement = mediaSourceService.getAudioElement();
-		if (!audioElement) throw new Error("Audio element not available from MediaSourceService");
-		let mediaElementSource;
-		try {
-			mediaElementSource = audioContext.createMediaElementSource(audioElement);
-		} catch (error) {
-			if (error instanceof Error && error.message.includes("already connected")) {
-				this.clearCache();
-				try {
-					mediaElementSource = audioContext.createMediaElementSource(audioElement);
-				} catch (retryError) {
-					console.warn("AudioElementFactory: Failed to create MediaElementSource even after clearing cache:", retryError);
-					throw retryError;
-				}
-			} else throw error;
-		}
-		this.currentSource = mediaElementSource;
-		this.currentAudioContext = audioContext;
-		this.cache.set(audioContext, mediaElementSource);
-		const cleanup = () => {
-			if (audioContext.state === "closed") {
-				this.cache.delete(audioContext);
-				if (this.currentAudioContext === audioContext) {
-					this.currentSource = null;
-					this.currentAudioContext = null;
-				}
-				audioContext.removeEventListener("statechange", cleanup);
-			}
-		};
-		audioContext.addEventListener("statechange", cleanup);
-		return mediaElementSource;
-	}
-	/**
-	* Clear all cached sources (useful for testing or cleanup)
-	*/
-	clearCache() {
-		if (this.currentSource) this.currentSource.disconnect();
-		this.cache = /* @__PURE__ */ new WeakMap();
-		this.currentSource = null;
-		this.currentAudioContext = null;
-	}
-	/**
-	* Check if we have a cached source for the given AudioContext
-	*/
-	hasCachedSource(audioContext) {
-		return this.cache.has(audioContext) && audioContext.state !== "closed";
-	}
-};
-export { AudioElementFactory };

package/dist/elements/EFMedia/services/MediaSourceService.browsertest.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/elements/EFMedia/services/MediaSourceService.d.ts

@@ -1,47 +0,0 @@
-export interface MediaSourceServiceOptions {
-    onError?: (error: Error) => void;
-    onReady?: () => void;
-    onUpdateEnd?: () => void;
-    timeout?: number;
-}
-/**
- * Service for managing MediaSource lifecycle and audio element creation
- * Extracted from EFMedia to improve separation of concerns and testability
- */
-export declare class MediaSourceService {
-    private mediaSourceManager;
-    private options;
-    constructor(options?: MediaSourceServiceOptions);
-    /**
-     * Initialize MediaSource if not already initialized
-     */
-    ensureInitialized(): Promise<void>;
-    /**
-     * Initialize fresh MediaSource
-     */
-    initialize(): Promise<void>;
-    /**
-     * Get audio element for MediaElementSource creation
-     */
-    getAudioElement(): HTMLAudioElement | null;
-    /**
-     * Feed audio segments to MediaSource
-     */
-    feedSegment(segmentBuffer: ArrayBuffer): Promise<void>;
-    /**
-     * Check if MediaSource is ready
-     */
-    isReady(): boolean;
-    /**
-     * Get buffered time ranges
-     */
-    getBuffered(): TimeRanges | null;
-    /**
-     * Set audio element current time
-     */
-    setCurrentTime(timeMs: number): void;
-    /**
-     * Clean up MediaSource resources
-     */
-    cleanup(): void;
-}

package/dist/elements/EFMedia/services/MediaSourceService.js

@@ -1,73 +0,0 @@
-import { MediaSourceManager } from "../../../services/MediaSourceManager.js";
-/**
-* Service for managing MediaSource lifecycle and audio element creation
-* Extracted from EFMedia to improve separation of concerns and testability
-*/
-var MediaSourceService = class {
-	constructor(options = {}) {
-		this.mediaSourceManager = null;
-		this.options = options;
-	}
-	/**
-	* Initialize MediaSource if not already initialized
-	*/
-	async ensureInitialized() {
-		if (this.mediaSourceManager?.isReady()) return;
-		await this.initialize();
-	}
-	/**
-	* Initialize fresh MediaSource
-	*/
-	async initialize() {
-		this.cleanup();
-		const managerOptions = {
-			onError: this.options.onError,
-			onReady: this.options.onReady,
-			onUpdateEnd: this.options.onUpdateEnd,
-			timeout: this.options.timeout
-		};
-		this.mediaSourceManager = new MediaSourceManager(managerOptions);
-		await this.mediaSourceManager.initialize();
-	}
-	/**
-	* Get audio element for MediaElementSource creation
-	*/
-	getAudioElement() {
-		return this.mediaSourceManager?.getAudioElement() || null;
-	}
-	/**
-	* Feed audio segments to MediaSource
-	*/
-	async feedSegment(segmentBuffer) {
-		await this.ensureInitialized();
-		if (this.mediaSourceManager) await this.mediaSourceManager.feedSegment(segmentBuffer);
-	}
-	/**
-	* Check if MediaSource is ready
-	*/
-	isReady() {
-		return this.mediaSourceManager?.isReady() ?? false;
-	}
-	/**
-	* Get buffered time ranges
-	*/
-	getBuffered() {
-		return this.mediaSourceManager?.getBuffered() || null;
-	}
-	/**
-	* Set audio element current time
-	*/
-	setCurrentTime(timeMs) {
-		this.mediaSourceManager?.setCurrentTime(timeMs);
-	}
-	/**
-	* Clean up MediaSource resources
-	*/
-	cleanup() {
-		if (this.mediaSourceManager) {
-			this.mediaSourceManager.cleanup();
-			this.mediaSourceManager = null;
-		}
-	}
-};
-export { MediaSourceService };

package/dist/gui/services/ElementConnectionManager.browsertest.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/gui/services/ElementConnectionManager.d.ts

@@ -1,59 +0,0 @@
-/**
- * Manages dynamic connection/disconnection of media elements to AudioContext
- * Extracted from ContextMixin to improve separation of concerns and testability
- */
-export declare class ElementConnectionManager {
-    private connectedMediaSources;
-    private lookaheadMs;
-    constructor(lookaheadMs?: number);
-    /**
-     * Update connected media elements based on current playhead position
-     * Connects upcoming elements and disconnects past elements
-     */
-    updateConnectedElements(audioContext: AudioContext, timegroup: any, // EFTimegroup type
-    currentMs: number): Promise<void>;
-    /**
-     * Find elements that should be connected based on timeline position
-     */
-    private getElementsToConnect;
-    /**
-     * Connect new elements that aren't already connected
-     */
-    private connectNewElements;
-    /**
-     * Update connection states for all managed elements
-     */
-    private updateElementStates;
-    /**
-     * Activate an element (connect to destination and start playback)
-     */
-    private activateElement;
-    /**
-     * Deactivate an element (disconnect but keep prepared)
-     */
-    private deactivateElement;
-    /**
-     * Clean up elements that are far in the past
-     */
-    private cleanupOldElements;
-    /**
-     * Clear all connected media sources (for cleanup)
-     */
-    clearAll(): void;
-    /**
-     * Get connection status for testing/debugging
-     */
-    getConnectionInfo(): {
-        total: number;
-        connected: number;
-        prepared: number;
-    };
-    /**
-     * Set lookahead time
-     */
-    setLookaheadMs(lookaheadMs: number): void;
-    /**
-     * Get current lookahead time
-     */
-    getLookaheadMs(): number;
-}

package/dist/gui/services/ElementConnectionManager.js

@@ -1,128 +0,0 @@
-/**
-* Manages dynamic connection/disconnection of media elements to AudioContext
-* Extracted from ContextMixin to improve separation of concerns and testability
-*/
-var ElementConnectionManager = class {
-	constructor(lookaheadMs = 3e3) {
-		this.connectedMediaSources = /* @__PURE__ */ new Map();
-		this.lookaheadMs = lookaheadMs;
-	}
-	/**
-	* Update connected media elements based on current playhead position
-	* Connects upcoming elements and disconnects past elements
-	*/
-	async updateConnectedElements(audioContext, timegroup, currentMs) {
-		if (!audioContext || audioContext.state === "closed") return;
-		const allMediaElements = Array.from(timegroup.querySelectorAll("ef-audio, ef-video"));
-		const lookaheadMs = currentMs + this.lookaheadMs;
-		const elementsToConnect = this.getElementsToConnect(allMediaElements, currentMs, lookaheadMs);
-		await this.connectNewElements(audioContext, elementsToConnect);
-		await this.updateElementStates(currentMs);
-		this.cleanupOldElements(currentMs);
-	}
-	/**
-	* Find elements that should be connected based on timeline position
-	*/
-	getElementsToConnect(allElements, currentMs, lookaheadMs) {
-		return allElements.filter((mediaElement) => {
-			const startTime = mediaElement.startTimeMs;
-			const endTime = mediaElement.endTimeMs;
-			const isCurrentlyActive = currentMs >= startTime && currentMs < endTime;
-			const isStartingSoon = startTime > currentMs && startTime <= lookaheadMs;
-			return isCurrentlyActive || isStartingSoon;
-		});
-	}
-	/**
-	* Connect new elements that aren't already connected
-	*/
-	async connectNewElements(audioContext, elementsToConnect) {
-		for (const mediaElement of elementsToConnect) if (!this.connectedMediaSources.has(mediaElement)) {
-			const mediaElementSource = await mediaElement.getMediaElementSource(audioContext);
-			this.connectedMediaSources.set(mediaElement, {
-				mediaElementSource,
-				connected: false
-			});
-		}
-	}
-	/**
-	* Update connection states for all managed elements
-	*/
-	async updateElementStates(currentMs) {
-		for (const [mediaElement, sourceInfo] of this.connectedMediaSources.entries()) {
-			const startTime = mediaElement.startTimeMs;
-			const endTime = mediaElement.endTimeMs;
-			const isCurrentlyActive = currentMs >= startTime && currentMs < endTime;
-			if (isCurrentlyActive && !sourceInfo.connected) await this.activateElement(mediaElement, sourceInfo);
-			else if (!isCurrentlyActive && sourceInfo.connected) await this.deactivateElement(mediaElement, sourceInfo);
-		}
-	}
-	/**
-	* Activate an element (connect to destination and start playback)
-	*/
-	async activateElement(mediaElement, sourceInfo) {
-		sourceInfo.mediaElementSource.connect(sourceInfo.mediaElementSource.context.destination);
-		sourceInfo.connected = true;
-		if (mediaElement.audioElement) {
-			const mediaTimeMs = mediaElement.currentSourceTimeMs;
-			mediaElement.audioElement.currentTime = mediaTimeMs / 1e3;
-			await mediaElement.audioElement.play();
-		}
-	}
-	/**
-	* Deactivate an element (disconnect but keep prepared)
-	*/
-	async deactivateElement(mediaElement, sourceInfo) {
-		sourceInfo.mediaElementSource.disconnect();
-		sourceInfo.connected = false;
-		if (mediaElement.audioElement) mediaElement.audioElement.pause();
-	}
-	/**
-	* Clean up elements that are far in the past
-	*/
-	cleanupOldElements(currentMs) {
-		const cleanupThresholdMs = currentMs - this.lookaheadMs;
-		for (const [mediaElement, sourceInfo] of this.connectedMediaSources.entries()) {
-			const endTime = mediaElement.endTimeMs;
-			if (endTime < cleanupThresholdMs) {
-				if (sourceInfo.connected) sourceInfo.mediaElementSource.disconnect();
-				this.connectedMediaSources.delete(mediaElement);
-			}
-		}
-	}
-	/**
-	* Clear all connected media sources (for cleanup)
-	*/
-	clearAll() {
-		for (const [, sourceInfo] of this.connectedMediaSources.entries()) try {
-			if (sourceInfo.connected) sourceInfo.mediaElementSource.disconnect();
-		} catch (_error) {}
-		this.connectedMediaSources.clear();
-	}
-	/**
-	* Get connection status for testing/debugging
-	*/
-	getConnectionInfo() {
-		let connected = 0;
-		let prepared = 0;
-		for (const [, sourceInfo] of this.connectedMediaSources.entries()) if (sourceInfo.connected) connected++;
-		else prepared++;
-		return {
-			total: this.connectedMediaSources.size,
-			connected,
-			prepared
-		};
-	}
-	/**
-	* Set lookahead time
-	*/
-	setLookaheadMs(lookaheadMs) {
-		this.lookaheadMs = lookaheadMs;
-	}
-	/**
-	* Get current lookahead time
-	*/
-	getLookaheadMs() {
-		return this.lookaheadMs;
-	}
-};
-export { ElementConnectionManager };

package/dist/gui/services/PlaybackController.browsertest.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/gui/services/PlaybackController.d.ts

@@ -1,103 +0,0 @@
-export interface PlaybackControllerOptions {
-    fps?: number;
-    onTimeUpdate?: (timeMs: number) => void;
-    onPlayStateChange?: (playing: boolean) => void;
-    onError?: (error: Error) => void;
-}
-/**
- * Manages playback timing, AudioContext lifecycle, and timeline synchronization
- * Extracted from ContextMixin to improve separation of concerns and testability
- */
-export declare class PlaybackController {
-    private playbackAudioContext;
-    private animationFrameRequest;
-    private options;
-    private playing;
-    private currentTimeMs;
-    private msPerFrame;
-    private audioStartTime;
-    private playbackStartTimeMs;
-    private activeChunks;
-    private chunkDurationMs;
-    private lookaheadChunks;
-    private currentChunkIndex;
-    private renderingChunks;
-    constructor(options?: PlaybackControllerOptions);
-    /**
-     * Start playback for the given timegroup
-     */
-    startPlayback(timegroup: any, fromMs?: number): Promise<void>;
-    /**
-     * Stop playback and clean up resources
-     */
-    stopPlayback(): Promise<void>;
-    /**
-     * Pause playback (can be resumed)
-     */
-    pausePlayback(): Promise<void>;
-    /**
-     * Resume paused playback
-     */
-    resumePlayback(): Promise<void>;
-    /**
-     * Seek to a specific time (restarts progressive playback from new position)
-     */
-    seekTo(timeMs: number, timegroup?: any): Promise<void>;
-    /**
-     * Internal method to sync playhead with unified audio buffer timing
-     */
-    private syncPlayheadToAudioBuffer;
-    /**
-     * Update playing state and notify observers
-     */
-    private setPlaying;
-    /**
-     * Get current playback state
-     */
-    isPlaying(): boolean;
-    /**
-     * Get current time
-     */
-    getCurrentTime(): number;
-    /**
-     * Get current AudioContext
-     */
-    getAudioContext(): AudioContext | null;
-    /**
-     * Check if AudioContext is ready
-     */
-    isAudioContextReady(): boolean;
-    /**
-     * Get playback statistics for debugging
-     */
-    getPlaybackInfo(): {
-        playing: boolean;
-        currentTimeMs: number;
-        audioContextState: string | null;
-        hasElementManager: boolean;
-    };
-    /**
-     * Update playback options
-     */
-    updateOptions(options: Partial<PlaybackControllerOptions>): void;
-    /**
-     * Start progressive chunk rendering and playback
-     */
-    private startProgressivePlayback;
-    /**
-     * Render and schedule a single audio chunk
-     */
-    private renderAndScheduleChunk;
-    /**
-     * Update chunk rendering as playhead advances - now handles all chunk management
-     */
-    private updateProgressiveChunks;
-    /**
-     * Systematically ensure chunks are ready ahead of current playback (synchronous)
-     */
-    private ensureChunksAhead;
-    /**
-     * Clean up chunks that are behind the current playhead
-     */
-    private cleanupOldChunks;
-}