@editframe/elements 0.16.7-beta.0 → 0.17.6-beta.0

package/dist/JitTranscodingClient.d.ts

@@ -0,0 +1,167 @@
+/**
+ * JIT Transcoding Client for Elements
+ * Handles communication with the JIT transcoding service for real-time video streaming
+ */
+export interface QualityPreset {
+    name: string;
+    width: number;
+    height: number;
+    videoBitrate: number;
+    audioBitrate: number;
+    audioChannels: number;
+    audioSampleRate: number;
+    audioCodec: "aac";
+}
+export interface VideoMetadata {
+    url: string;
+    durationMs: number;
+    streams: Array<{
+        index: number;
+        type: "video" | "audio" | "subtitle" | "other";
+        codecName: string;
+        duration: number;
+        durationMs: number;
+        width?: number;
+        height?: number;
+        frameRate?: {
+            num: number;
+            den: number;
+        };
+        channels?: number;
+        sampleRate?: number;
+    }>;
+    presets: string[];
+    segmentDuration: number;
+    supportedFormats: string[];
+    extractedAt: string;
+}
+export interface JitTranscodingConfig {
+    baseUrl: string;
+    defaultQuality: keyof QualityPresets;
+    segmentCacheSize: number;
+    enableNetworkAdaptation: boolean;
+    enablePrefetch: boolean;
+    prefetchSegments: number;
+}
+export interface QualityPresets {
+    low: QualityPreset;
+    medium: QualityPreset;
+    high: QualityPreset;
+}
+export interface NetworkCondition {
+    bandwidth: number;
+    rtt: number;
+    connectionType: string;
+}
+export interface SegmentInfo {
+    url: string;
+    startTimeMs: number;
+    durationMs: number;
+    quality: string;
+    cached: boolean;
+}
+export declare class JitTranscodingClient {
+    private config;
+    private segmentCache;
+    private metadataCache;
+    private qualityPresets;
+    private currentQuality;
+    private networkMonitor;
+    private pendingRequests;
+    private cacheHits;
+    private cacheMisses;
+    private totalRequests;
+    private cacheAccessOrder;
+    constructor(config?: Partial<JitTranscodingConfig>);
+    /**
+     * Check if a URL is eligible for JIT transcoding
+     */
+    static isJitTranscodeEligible(url: string): boolean;
+    /**
+     * Instance method to check if a URL is eligible for JIT transcoding
+     */
+    isJitTranscodeEligible(url: string): boolean;
+    /**
+     * Load quality presets from the JIT transcoding service
+     */
+    loadQualityPresets(): Promise<QualityPresets>;
+    /**
+     * Internal method to actually fetch quality presets
+     */
+    private fetchQualityPresets;
+    /**
+     * Load video metadata from the JIT transcoding service
+     */
+    loadVideoMetadata(url: string): Promise<VideoMetadata>;
+    /**
+     * Internal method to actually fetch video metadata
+     */
+    private fetchVideoMetadata;
+    /**
+     * Get the appropriate quality based on network conditions
+     */
+    getAdaptiveQuality(): Promise<keyof QualityPresets>;
+    /**
+     * Generate segment URL for JIT transcoding
+     */
+    generateSegmentUrl(videoUrl: string, startTimeMs: number, quality?: keyof QualityPresets): string;
+    /**
+     * Fetch a video segment with caching
+     */
+    fetchSegment(videoUrl: string, startTimeMs: number, quality?: keyof QualityPresets): Promise<ArrayBuffer>;
+    /**
+     * Internal method to actually fetch a video segment
+     */
+    private fetchVideoSegment;
+    /**
+     * Prefetch upcoming segments
+     */
+    prefetchSegments(videoUrl: string, currentTimeMs: number, quality?: keyof QualityPresets): Promise<void>;
+    /**
+     * Cache a segment with LRU eviction
+     */
+    private cacheSegment;
+    /**
+     * Get comprehensive cache statistics
+     */
+    getCacheStats(): {
+        size: number;
+        maxSize: number;
+        hitRate: number;
+        efficiency: number;
+        totalRequests: number;
+        recentKeys: string[];
+    };
+    /**
+     * Clear all caches
+     */
+    clearCache(): void;
+    /**
+     * Set manual quality override
+     */
+    setQuality(quality: keyof QualityPresets): void;
+    /**
+     * Get current quality setting
+     */
+    getCurrentQuality(): keyof QualityPresets;
+    /**
+     * Load a video segment for any quality preset including scrub
+     */
+    loadSegment(videoUrl: string, quality: string, startTimeMs: number): Promise<ArrayBuffer>;
+    /**
+     * Load a scrub track segment (30s duration)
+     */
+    private loadScrubSegment;
+    /**
+     * Internal method to fetch scrub segment
+     */
+    private fetchScrubSegment;
+    /**
+     * Check if a segment is cached for a given quality
+     */
+    hasSegmentInCache(videoUrl: string, quality: string, timeMs: number): boolean;
+    /**
+     * Get video metadata
+     */
+    getMetadata(videoUrl: string): Promise<VideoMetadata>;
+}

package/dist/JitTranscodingClient.js

@@ -0,0 +1,373 @@
+var JitTranscodingClient = class JitTranscodingClient {
+	constructor(config = {}) {
+		this.segmentCache = /* @__PURE__ */ new Map();
+		this.metadataCache = /* @__PURE__ */ new Map();
+		this.qualityPresets = null;
+		this.pendingRequests = /* @__PURE__ */ new Map();
+		this.cacheHits = 0;
+		this.cacheMisses = 0;
+		this.totalRequests = 0;
+		this.cacheAccessOrder = [];
+		this.config = {
+			baseUrl: "http://localhost:3000",
+			defaultQuality: "medium",
+			segmentCacheSize: 50,
+			enableNetworkAdaptation: true,
+			enablePrefetch: true,
+			prefetchSegments: 3,
+			...config
+		};
+		this.currentQuality = this.config.defaultQuality;
+		this.networkMonitor = new NetworkMonitor();
+	}
+	/**
+	* Check if a URL is eligible for JIT transcoding
+	*/
+	static isJitTranscodeEligible(url) {
+		return url.startsWith("http://") || url.startsWith("https://");
+	}
+	/**
+	* Instance method to check if a URL is eligible for JIT transcoding
+	*/
+	isJitTranscodeEligible(url) {
+		return JitTranscodingClient.isJitTranscodeEligible(url);
+	}
+	/**
+	* Load quality presets from the JIT transcoding service
+	*/
+	async loadQualityPresets() {
+		if (this.qualityPresets) return this.qualityPresets;
+		const requestKey = "quality-presets";
+		const pendingRequest = this.pendingRequests.get(requestKey);
+		if (pendingRequest) return pendingRequest;
+		const requestPromise = this.fetchQualityPresets();
+		this.pendingRequests.set(requestKey, requestPromise);
+		try {
+			const result = await requestPromise;
+			this.pendingRequests.delete(requestKey);
+			return result;
+		} catch (error) {
+			this.pendingRequests.delete(requestKey);
+			throw error;
+		}
+	}
+	/**
+	* Internal method to actually fetch quality presets
+	*/
+	async fetchQualityPresets() {
+		try {
+			const response = await fetch(`${this.config.baseUrl}/api/v1/transcode/presets`);
+			if (!response.ok) throw new Error(`Failed to load quality presets: ${response.status}`);
+			const data = await response.json();
+			this.qualityPresets = data.presets;
+			if (!this.qualityPresets) throw new Error("No quality presets found");
+			return this.qualityPresets;
+		} catch (error) {
+			console.error("Failed to load quality presets:", error);
+			this.qualityPresets = {
+				low: {
+					name: "low",
+					width: 480,
+					height: 270,
+					videoBitrate: 4e5,
+					audioBitrate: 64e3,
+					audioChannels: 2,
+					audioSampleRate: 48e3,
+					audioCodec: "aac"
+				},
+				medium: {
+					name: "medium",
+					width: 854,
+					height: 480,
+					videoBitrate: 1e6,
+					audioBitrate: 128e3,
+					audioChannels: 2,
+					audioSampleRate: 48e3,
+					audioCodec: "aac"
+				},
+				high: {
+					name: "high",
+					width: 1280,
+					height: 720,
+					videoBitrate: 25e5,
+					audioBitrate: 192e3,
+					audioChannels: 2,
+					audioSampleRate: 48e3,
+					audioCodec: "aac"
+				}
+			};
+			return this.qualityPresets;
+		}
+	}
+	/**
+	* Load video metadata from the JIT transcoding service
+	*/
+	async loadVideoMetadata(url) {
+		const cached = this.metadataCache.get(url);
+		if (cached) return cached;
+		const requestKey = `metadata:${url}`;
+		const pendingRequest = this.pendingRequests.get(requestKey);
+		if (pendingRequest) return pendingRequest;
+		const requestPromise = this.fetchVideoMetadata(url);
+		this.pendingRequests.set(requestKey, requestPromise);
+		try {
+			const result = await requestPromise;
+			this.pendingRequests.delete(requestKey);
+			return result;
+		} catch (error) {
+			this.pendingRequests.delete(requestKey);
+			throw error;
+		}
+	}
+	/**
+	* Internal method to actually fetch video metadata
+	*/
+	async fetchVideoMetadata(url) {
+		try {
+			const response = await fetch(`${this.config.baseUrl}/api/v1/transcode/metadata?url=${encodeURIComponent(url)}`);
+			if (!response.ok) throw new Error(`Failed to load video metadata: ${response.status}`);
+			const metadata = await response.json();
+			this.metadataCache.set(url, metadata);
+			return metadata;
+		} catch (error) {
+			console.error("Failed to load video metadata:", error);
+			throw error;
+		}
+	}
+	/**
+	* Get the appropriate quality based on network conditions
+	*/
+	async getAdaptiveQuality() {
+		if (!this.config.enableNetworkAdaptation) return this.currentQuality;
+		const networkCondition = await this.networkMonitor.getCurrentCondition();
+		if (networkCondition.bandwidth < 8e5) return "low";
+		if (networkCondition.bandwidth < 2e6) return "medium";
+		return "high";
+	}
+	/**
+	* Generate segment URL for JIT transcoding
+	*/
+	generateSegmentUrl(videoUrl, startTimeMs, quality = this.currentQuality) {
+		const alignedStartTime = Math.floor(startTimeMs / 2e3) * 2e3;
+		return `${this.config.baseUrl}/api/v1/transcode/${quality}?url=${encodeURIComponent(videoUrl)}&start=${alignedStartTime}`;
+	}
+	/**
+	* Fetch a video segment with caching
+	*/
+	async fetchSegment(videoUrl, startTimeMs, quality) {
+		const effectiveQuality = quality || await this.getAdaptiveQuality();
+		const segmentUrl = this.generateSegmentUrl(videoUrl, startTimeMs, effectiveQuality);
+		const cacheKey = `${videoUrl}:${startTimeMs}:${effectiveQuality}`;
+		const cached = this.segmentCache.get(cacheKey);
+		if (cached) {
+			this.cacheHits++;
+			return cached;
+		}
+		const requestKey = `segment:${cacheKey}`;
+		const pendingRequest = this.pendingRequests.get(requestKey);
+		if (pendingRequest) return pendingRequest;
+		const requestPromise = this.fetchVideoSegment(segmentUrl, cacheKey, effectiveQuality);
+		this.pendingRequests.set(requestKey, requestPromise);
+		try {
+			const result = await requestPromise;
+			this.pendingRequests.delete(requestKey);
+			return result;
+		} catch (error) {
+			this.pendingRequests.delete(requestKey);
+			throw error;
+		}
+	}
+	/**
+	* Internal method to actually fetch a video segment
+	*/
+	async fetchVideoSegment(segmentUrl, cacheKey, effectiveQuality) {
+		try {
+			const response = await fetch(segmentUrl);
+			if (!response.ok) throw new Error(`Failed to fetch segment: ${response.status}`);
+			const buffer = await response.arrayBuffer();
+			this.cacheSegment(cacheKey, buffer);
+			this.currentQuality = effectiveQuality;
+			this.cacheMisses++;
+			return buffer;
+		} catch (error) {
+			console.error("Failed to fetch segment:", error);
+			throw error;
+		}
+	}
+	/**
+	* Prefetch upcoming segments
+	*/
+	async prefetchSegments(videoUrl, currentTimeMs, quality) {
+		if (!this.config.enablePrefetch) return;
+		const effectiveQuality = quality || this.currentQuality;
+		const segmentDuration = 2e3;
+		const prefetchPromises = [];
+		for (let i = 1; i <= this.config.prefetchSegments; i++) {
+			const nextSegmentStart = currentTimeMs + i * segmentDuration;
+			const cacheKey = `${videoUrl}:${nextSegmentStart}:${effectiveQuality}`;
+			if (!this.segmentCache.has(cacheKey)) prefetchPromises.push(this.fetchSegment(videoUrl, nextSegmentStart, effectiveQuality).catch((error) => {
+				console.warn(`Failed to prefetch segment at ${nextSegmentStart}ms:`, error);
+				return /* @__PURE__ */ new ArrayBuffer(0);
+			}));
+		}
+		Promise.allSettled(prefetchPromises).then(() => {
+			console.debug(`Prefetched ${prefetchPromises.length} segments`);
+		});
+	}
+	/**
+	* Cache a segment with LRU eviction
+	*/
+	cacheSegment(cacheKey, buffer) {
+		if (this.segmentCache.size >= this.config.segmentCacheSize) {
+			const firstKey = this.segmentCache.keys().next().value;
+			if (firstKey) {
+				this.segmentCache.delete(firstKey);
+				const index = this.cacheAccessOrder.indexOf(firstKey);
+				if (index > -1) this.cacheAccessOrder.splice(index, 1);
+			}
+		}
+		this.segmentCache.set(cacheKey, buffer);
+		const existingIndex = this.cacheAccessOrder.indexOf(cacheKey);
+		if (existingIndex > -1) this.cacheAccessOrder.splice(existingIndex, 1);
+		this.cacheAccessOrder.push(cacheKey);
+	}
+	/**
+	* Get comprehensive cache statistics
+	*/
+	getCacheStats() {
+		this.totalRequests = this.cacheHits + this.cacheMisses;
+		const hitRate = this.totalRequests > 0 ? this.cacheHits / this.totalRequests : 0;
+		const efficiency = this.segmentCache.size > 0 ? this.cacheHits / this.segmentCache.size : 0;
+		return {
+			size: this.segmentCache.size,
+			maxSize: this.config.segmentCacheSize,
+			hitRate,
+			efficiency,
+			totalRequests: this.totalRequests,
+			recentKeys: this.cacheAccessOrder.slice(-5)
+		};
+	}
+	/**
+	* Clear all caches
+	*/
+	clearCache() {
+		this.segmentCache.clear();
+		this.metadataCache.clear();
+		this.pendingRequests.clear();
+	}
+	/**
+	* Set manual quality override
+	*/
+	setQuality(quality) {
+		this.currentQuality = quality;
+	}
+	/**
+	* Get current quality setting
+	*/
+	getCurrentQuality() {
+		return this.currentQuality;
+	}
+	/**
+	* Load a video segment for any quality preset including scrub
+	*/
+	async loadSegment(videoUrl, quality, startTimeMs) {
+		if (quality === "scrub") return this.loadScrubSegment(videoUrl, startTimeMs);
+		return this.fetchSegment(videoUrl, startTimeMs, quality);
+	}
+	/**
+	* Load a scrub track segment (30s duration)
+	*/
+	async loadScrubSegment(videoUrl, startTimeMs) {
+		const alignedStartTime = Math.floor(startTimeMs / 3e4) * 3e4;
+		const segmentUrl = `${this.config.baseUrl}/api/v1/transcode/scrub?url=${encodeURIComponent(videoUrl)}&start=${alignedStartTime}`;
+		const cacheKey = `${videoUrl}:${alignedStartTime}:scrub`;
+		const cached = this.segmentCache.get(cacheKey);
+		if (cached) {
+			this.cacheHits++;
+			return cached;
+		}
+		const requestKey = `scrub:${cacheKey}`;
+		const pendingRequest = this.pendingRequests.get(requestKey);
+		if (pendingRequest) return pendingRequest;
+		const requestPromise = this.fetchScrubSegment(segmentUrl, cacheKey);
+		this.pendingRequests.set(requestKey, requestPromise);
+		try {
+			const result = await requestPromise;
+			this.pendingRequests.delete(requestKey);
+			return result;
+		} catch (error) {
+			this.pendingRequests.delete(requestKey);
+			throw error;
+		}
+	}
+	/**
+	* Internal method to fetch scrub segment
+	*/
+	async fetchScrubSegment(segmentUrl, cacheKey) {
+		try {
+			const response = await fetch(segmentUrl);
+			if (!response.ok) throw new Error(`Failed to fetch scrub segment: ${response.status}`);
+			const buffer = await response.arrayBuffer();
+			this.cacheSegment(cacheKey, buffer);
+			this.cacheMisses++;
+			return buffer;
+		} catch (error) {
+			console.error("Failed to fetch scrub segment:", error);
+			throw error;
+		}
+	}
+	/**
+	* Check if a segment is cached for a given quality
+	*/
+	hasSegmentInCache(videoUrl, quality, timeMs) {
+		let alignedTime;
+		let cacheKey;
+		if (quality === "scrub") {
+			alignedTime = Math.floor(timeMs / 3e4) * 3e4;
+			cacheKey = `${videoUrl}:${alignedTime}:scrub`;
+		} else {
+			alignedTime = Math.floor(timeMs / 2e3) * 2e3;
+			cacheKey = `${videoUrl}:${alignedTime}:${quality}`;
+		}
+		return this.segmentCache.has(cacheKey);
+	}
+	/**
+	* Get video metadata
+	*/
+	async getMetadata(videoUrl) {
+		return this.loadVideoMetadata(videoUrl);
+	}
+};
+/**
+* Network condition monitoring
+*/
+var NetworkMonitor = class {
+	constructor() {
+		this.measurementHistory = [];
+	}
+	async getCurrentCondition() {
+		const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+		if (connection) return {
+			bandwidth: (connection.downlink || 1) * 1e6,
+			rtt: connection.rtt || 100,
+			connectionType: connection.effectiveType || "unknown"
+		};
+		const estimatedBandwidth = this.estimateBandwidth();
+		return {
+			bandwidth: estimatedBandwidth,
+			rtt: 100,
+			connectionType: "unknown"
+		};
+	}
+	estimateBandwidth() {
+		if (this.measurementHistory.length === 0) return 1e6;
+		const average = this.measurementHistory.reduce((a, b) => a + b, 0) / this.measurementHistory.length;
+		return Math.max(average, 4e5);
+	}
+	measureBandwidth(bytes, timeMs) {
+		const bandwidth = bytes * 8 / (timeMs / 1e3);
+		this.measurementHistory.push(bandwidth);
+		if (this.measurementHistory.length > 10) this.measurementHistory.shift();
+	}
+};
+export { JitTranscodingClient };

package/dist/JitTranscodingClient.test.d.ts

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

package/dist/LoadingDebounce.test.d.ts

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

package/dist/ManualScrubTest.test.d.ts

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

package/dist/ScrubResolvedFlashing.test.d.ts

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

package/dist/ScrubTrackIntegration.test.d.ts

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

package/dist/ScrubTrackManager.d.ts

@@ -0,0 +1,96 @@
+import { JitTranscodingClient } from './JitTranscodingClient.js';
+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: 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;
+}