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

package/dist/ScrubTrackManager.js

@@ -1,216 +0,0 @@
-import debug from "debug";
-import { VideoAsset } from "@editframe/assets/EncodedAsset.js";
-const log = debug("ef:elements:ScrubTrackManager");
-var ScrubTrackManager = class {
-	constructor(videoUrl, jitClient, config = {}) {
-		this.scrubCache = /* @__PURE__ */ new Map();
-		this.metadata = null;
-		this.cacheHits = 0;
-		this.cacheMisses = 0;
-		this.isInitialized = false;
-		this.preloadingSegments = /* @__PURE__ */ new Set();
-		this.videoUrl = videoUrl;
-		this.jitClient = jitClient;
-		this.config = {
-			maxScrubCacheSegments: 10,
-			prefetchCount: 3,
-			fastSeekThresholdMs: 1e4,
-			onLoadingStateChange: () => {},
-			...config
-		};
-	}
-	/**
-	* Initialize scrub track manager and start preloading
-	*/
-	async initialize() {
-		if (this.isInitialized) return;
-		try {
-			this.metadata = await this.jitClient.getMetadata(this.videoUrl);
-			await this.preloadInitialSegments();
-			this.isInitialized = true;
-			log("ScrubTrackManager initialized for", this.videoUrl);
-		} catch (error) {
-			log("Failed to initialize ScrubTrackManager:", error);
-			throw error;
-		}
-	}
-	/**
-	* Determine if scrub track should be used instead of normal video
-	*/
-	shouldUseScrubTrack(seekTimeMs) {
-		const currentQuality = this.jitClient.getCurrentQuality();
-		return !this.jitClient.hasSegmentInCache(this.videoUrl, currentQuality, seekTimeMs);
-	}
-	/**
-	* Detect if this is a fast seeking operation
-	*/
-	isFastSeeking(currentTimeMs, seekTimeMs) {
-		const timeDiff = Math.abs(seekTimeMs - currentTimeMs);
-		return timeDiff > this.config.fastSeekThresholdMs;
-	}
-	/**
-	* Align seek time to 30s scrub segment boundary
-	*/
-	alignToScrubBoundary(timeMs) {
-		const segmentDurationMs = 3e4;
-		return Math.floor(timeMs / segmentDurationMs) * segmentDurationMs;
-	}
-	/**
-	* Get scrub frame for the given seek time
-	*/
-	async getScrubFrame(seekTimeMs) {
-		const alignedTimeMs = this.alignToScrubBoundary(seekTimeMs);
-		try {
-			let videoAsset = this.scrubCache.get(alignedTimeMs);
-			const wasCached = !!videoAsset;
-			if (!videoAsset) {
-				this.config.onLoadingStateChange?.(true, "Loading scrub segment...");
-				const segmentBuffer = await this.jitClient.loadSegment(this.videoUrl, "scrub", alignedTimeMs);
-				this.config.onLoadingStateChange?.(true, "Processing video data...");
-				const segmentBlob = new Blob([segmentBuffer], { type: "video/mp4" });
-				const segmentFile = new File([segmentBlob], `scrub-${alignedTimeMs}.mp4`, { type: "video/mp4" });
-				const segmentId = `scrub-${this.videoUrl}-${alignedTimeMs}`;
-				videoAsset = await VideoAsset.createFromCompleteMP4(segmentId, segmentFile);
-				this.cacheSegment(alignedTimeMs, videoAsset);
-			}
-			const relativeSeekTimeMs = seekTimeMs - alignedTimeMs;
-			const relativeSeekTimeSeconds = relativeSeekTimeMs / 1e3;
-			log(`Seeking to ${relativeSeekTimeSeconds}s within scrub segment starting at ${alignedTimeMs}ms`);
-			const frame = await videoAsset.seekToTime(relativeSeekTimeSeconds);
-			if (!wasCached) this.config.onLoadingStateChange?.(false, "");
-			if (!frame) {
-				log(`Warning: No frame returned for seek to ${relativeSeekTimeSeconds}s in scrub segment`);
-				return null;
-			}
-			this.preloadNearbySegments(alignedTimeMs);
-			return frame;
-		} catch (error) {
-			this.config.onLoadingStateChange?.(false, "");
-			log("Failed to get scrub frame:", error);
-			return null;
-		}
-	}
-	/**
-	* Record cache hit for statistics
-	*/
-	recordCacheHit() {
-		this.cacheHits++;
-	}
-	/**
-	* Record cache miss for statistics
-	*/
-	recordCacheMiss() {
-		this.cacheMisses++;
-	}
-	/**
-	* Get cache performance statistics
-	*/
-	getCacheStats() {
-		const total = this.cacheHits + this.cacheMisses;
-		return {
-			hits: this.cacheHits,
-			misses: this.cacheMisses,
-			hitRate: total > 0 ? this.cacheHits / total : 0
-		};
-	}
-	/**
-	* Check if scrub segment is cached for the given time
-	*/
-	isScrubSegmentCached(seekTimeMs) {
-		const alignedTimeMs = this.alignToScrubBoundary(seekTimeMs);
-		return this.scrubCache.has(alignedTimeMs);
-	}
-	/**
-	* Get current scrub cache size
-	*/
-	getScrubCacheSize() {
-		return this.scrubCache.size;
-	}
-	/**
-	* Get total number of scrub segments for video
-	*/
-	getTotalScrubSegments() {
-		if (!this.metadata?.durationMs) return 0;
-		return Math.ceil(this.metadata.durationMs / 3e4);
-	}
-	/**
-	* Update metadata (e.g., when video duration changes)
-	*/
-	async updateMetadata() {
-		this.metadata = await this.jitClient.getMetadata(this.videoUrl);
-	}
-	/**
-	* Preload initial scrub segments
-	*/
-	async preloadInitialSegments() {
-		const segmentsToPreload = Math.min(this.config.prefetchCount, this.getTotalScrubSegments());
-		const preloadPromises = [];
-		for (let i = 0; i < segmentsToPreload; i++) {
-			const segmentStartMs = i * 3e4;
-			preloadPromises.push(this.preloadSegment(segmentStartMs));
-		}
-		await Promise.allSettled(preloadPromises);
-	}
-	/**
-	* Preload nearby segments around a given time
-	*/
-	preloadNearbySegments(centerTimeMs) {
-		const segmentDurationMs = 3e4;
-		const preloadCount = this.config.prefetchCount;
-		for (let i = 1; i <= preloadCount; i++) {
-			const nextSegmentTime = centerTimeMs + i * segmentDurationMs;
-			const prevSegmentTime = centerTimeMs - i * segmentDurationMs;
-			if (nextSegmentTime < (this.metadata?.durationMs || 0)) this.preloadSegment(nextSegmentTime);
-			if (prevSegmentTime >= 0) this.preloadSegment(prevSegmentTime);
-		}
-	}
-	/**
-	* Preload a single scrub segment (background operation)
-	*/
-	async preloadSegment(startTimeMs) {
-		if (this.scrubCache.has(startTimeMs) || this.preloadingSegments.has(startTimeMs)) return;
-		this.preloadingSegments.add(startTimeMs);
-		try {
-			const segmentBuffer = await this.jitClient.loadSegment(this.videoUrl, "scrub", startTimeMs);
-			const segmentBlob = new Blob([segmentBuffer], { type: "video/mp4" });
-			const segmentFile = new File([segmentBlob], `scrub-${startTimeMs}.mp4`, { type: "video/mp4" });
-			const segmentId = `scrub-${this.videoUrl}-${startTimeMs}`;
-			const videoAsset = await VideoAsset.createFromCompleteMP4(segmentId, segmentFile);
-			this.cacheSegment(startTimeMs, videoAsset);
-			log(`Preloaded scrub segment at ${startTimeMs}ms`);
-		} catch (error) {
-			log(`Failed to preload scrub segment at ${startTimeMs}ms:`, error);
-		} finally {
-			this.preloadingSegments.delete(startTimeMs);
-		}
-	}
-	/**
-	* Cache a scrub segment with LRU eviction
-	*/
-	cacheSegment(startTimeMs, videoAsset) {
-		if (this.scrubCache.size >= this.config.maxScrubCacheSegments) {
-			const oldestKey = this.scrubCache.keys().next().value;
-			if (oldestKey !== void 0) this.scrubCache.delete(oldestKey);
-		}
-		this.scrubCache.set(startTimeMs, videoAsset);
-	}
-	/**
-	* Clear cache and reset state
-	*/
-	reset() {
-		this.scrubCache.clear();
-		this.cacheHits = 0;
-		this.cacheMisses = 0;
-		this.preloadingSegments.clear();
-		this.isInitialized = false;
-		this.metadata = null;
-	}
-	/**
-	* Clean up resources and cancel any pending operations
-	*/
-	cleanup() {
-		this.config.onLoadingStateChange?.(false, "");
-		this.reset();
-	}
-};
-export { ScrubTrackManager };

package/dist/elements/printTaskStatus.js

@@ -1,11 +0,0 @@
-import { TaskStatus } from "@lit/task";
-const printTaskStatus = (status) => {
-	switch (status) {
-		case TaskStatus.INITIAL: return "INITIAL";
-		case TaskStatus.ERROR: return "ERROR";
-		case TaskStatus.PENDING: return "PENDING";
-		case TaskStatus.COMPLETE: return "COMPLETE";
-		default: return "UNKNOWN";
-	}
-};
-export { printTaskStatus };