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

package/dist/JitTranscodingClient.d.ts

@@ -1,167 +0,0 @@
-/**
- * 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

@@ -1,373 +0,0 @@
-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/ScrubTrackManager.d.ts

@@ -1,96 +0,0 @@
-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;
-}