@editframe/elements 0.18.22-beta.0 → 0.18.26-beta.0

package/dist/elements/EFMedia/tasks/makeMediaEngineTask.test.d.ts

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

package/dist/elements/EFMedia/videoTasks/makeVideoBufferTask.browsertest.d.ts

@@ -1,9 +0,0 @@
-import { EFVideo } from '../../EFVideo';
-declare class TestMediaVideoBuffer extends EFVideo {
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        "test-media-video-buffer": TestMediaVideoBuffer;
-    }
-}
-export {};

package/dist/elements/EFMedia/videoTasks/makeVideoInitSegmentFetchTask.browsertest.d.ts

@@ -1,9 +0,0 @@
-import { EFVideo } from '../../EFVideo';
-declare class TestMediaVideoInitSegmentFetch extends EFVideo {
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        "test-media-video-init-segment-fetch": TestMediaVideoInitSegmentFetch;
-    }
-}
-export {};

package/dist/elements/EFMedia/videoTasks/makeVideoInitSegmentFetchTask.js

@@ -1,16 +0,0 @@
-import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
-import { Task } from "@lit/task";
-const makeVideoInitSegmentFetchTask = (host) => {
-	return new Task(host, {
-		args: () => [host.mediaEngineTask.value],
-		onError: (error) => {
-			console.error("videoInitSegmentFetchTask error", error);
-		},
-		onComplete: (_value) => {},
-		task: async ([_mediaEngine], { signal }) => {
-			const mediaEngine = await getLatestMediaEngine(host, signal);
-			return mediaEngine.fetchInitSegment(mediaEngine.getVideoRendition(), signal);
-		}
-	});
-};
-export { makeVideoInitSegmentFetchTask };

package/dist/elements/EFMedia/videoTasks/makeVideoInputTask.browsertest.d.ts

@@ -1,9 +0,0 @@
-import { EFVideo } from '../../EFVideo';
-declare class TestMediaVideoInput extends EFVideo {
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        "test-media-video-input": TestMediaVideoInput;
-    }
-}
-export {};

package/dist/elements/EFMedia/videoTasks/makeVideoInputTask.js

@@ -1,27 +0,0 @@
-import { BufferedSeekingInput } from "../BufferedSeekingInput.js";
-import { EFMedia } from "../../EFMedia.js";
-import { Task } from "@lit/task";
-const makeVideoInputTask = (host) => {
-	return new Task(host, {
-		args: () => [host.videoInitSegmentFetchTask.value, host.videoSegmentFetchTask.value],
-		onError: (error) => {
-			console.error("videoInputTask error", error);
-		},
-		onComplete: (_value) => {},
-		task: async () => {
-			const initSegment = await host.videoInitSegmentFetchTask.taskComplete;
-			const segment = await host.videoSegmentFetchTask.taskComplete;
-			if (!initSegment || !segment) throw new Error("Init segment or segment is not available");
-			const mediaEngine = await host.mediaEngineTask.taskComplete;
-			const videoRendition = mediaEngine?.videoRendition;
-			const startTimeOffsetMs = videoRendition?.startTimeOffsetMs;
-			const input = new BufferedSeekingInput(await new Blob([initSegment, segment]).arrayBuffer(), {
-				videoBufferSize: EFMedia.VIDEO_SAMPLE_BUFFER_SIZE,
-				audioBufferSize: EFMedia.AUDIO_SAMPLE_BUFFER_SIZE,
-				startTimeOffsetMs
-			});
-			return input;
-		}
-	});
-};
-export { makeVideoInputTask };

package/dist/elements/EFMedia/videoTasks/makeVideoSeekTask.d.ts

@@ -1,7 +0,0 @@
-import { Task } from '@lit/task';
-import { VideoSample } from 'mediabunny';
-import { EFVideo } from '../../EFVideo';
-import { BufferedSeekingInput } from '../BufferedSeekingInput';
-type VideoSeekTask = Task<readonly [number, BufferedSeekingInput | undefined], VideoSample | undefined>;
-export declare const makeVideoSeekTask: (host: EFVideo) => VideoSeekTask;
-export {};

package/dist/elements/EFMedia/videoTasks/makeVideoSeekTask.js

@@ -1,34 +0,0 @@
-import { IgnorableError } from "../../EFMedia.js";
-import { Task } from "@lit/task";
-const makeVideoSeekTask = (host) => {
-	return new Task(host, {
-		args: () => [host.desiredSeekTimeMs, host.videoInputTask.value],
-		onError: (error) => {
-			if (error instanceof IgnorableError) console.info("videoSeekTask aborted");
-			console.error("videoSeekTask error", error);
-		},
-		onComplete: (_value) => {},
-		task: async ([targetSeekTimeMs], { signal }) => {
-			await host.mediaEngineTask.taskComplete;
-			signal.throwIfAborted();
-			await host.videoSegmentIdTask.taskComplete;
-			signal.throwIfAborted();
-			await host.videoSegmentFetchTask.taskComplete;
-			signal.throwIfAborted();
-			await host.videoInitSegmentFetchTask.taskComplete;
-			signal.throwIfAborted();
-			const videoInput = await host.videoInputTask.taskComplete;
-			signal.throwIfAborted();
-			if (!videoInput) throw new Error("Video input is not available");
-			const videoTrack = await videoInput.getFirstVideoTrack();
-			if (!videoTrack) throw new Error("Video track is not available");
-			signal.throwIfAborted();
-			const sample = await videoInput.seek(videoTrack.id, targetSeekTimeMs);
-			signal.throwIfAborted();
-			if (sample === void 0 && signal.aborted) return void 0;
-			if (sample === void 0) throw new Error("Video seek failed to find sample");
-			return sample;
-		}
-	});
-};
-export { makeVideoSeekTask };

package/dist/elements/EFMedia/videoTasks/makeVideoSegmentFetchTask.browsertest.d.ts

@@ -1,9 +0,0 @@
-import { EFVideo } from '../../EFVideo';
-declare class TestMediaVideoSegmentFetch extends EFVideo {
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        "test-media-video-segment-fetch": TestMediaVideoSegmentFetch;
-    }
-}
-export {};

package/dist/elements/EFMedia/videoTasks/makeVideoSegmentFetchTask.d.ts

@@ -1,4 +0,0 @@
-import { Task } from '@lit/task';
-import { MediaEngine } from '../../../transcoding/types';
-import { EFVideo } from '../../EFVideo';
-export declare const makeVideoSegmentFetchTask: (host: EFVideo) => Task<readonly [MediaEngine | undefined, number | undefined], ArrayBuffer>;

package/dist/elements/EFMedia/videoTasks/makeVideoSegmentFetchTask.js

@@ -1,28 +0,0 @@
-import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
-import { Task } from "@lit/task";
-const makeVideoSegmentFetchTask = (host) => {
-	return new Task(host, {
-		args: () => [host.mediaEngineTask.value, host.videoSegmentIdTask.value],
-		onError: (error) => {
-			console.error("videoSegmentFetchTask error", error);
-		},
-		onComplete: (_value) => {},
-		task: async (_, { signal }) => {
-			const mediaEngine = await getLatestMediaEngine(host, signal);
-			const segmentId = await host.videoSegmentIdTask.taskComplete;
-			if (segmentId === void 0) {
-				const rendition = mediaEngine.videoRendition;
-				const debugInfo = {
-					hasRendition: !!rendition,
-					segmentDurationMs: rendition?.segmentDurationMs,
-					segmentDurationsMs: rendition?.segmentDurationsMs?.length || 0,
-					desiredSeekTimeMs: host.desiredSeekTimeMs,
-					intrinsicDurationMs: host.intrinsicDurationMs
-				};
-				throw new Error(`Segment ID is not available for video. Debug info: ${JSON.stringify(debugInfo)}`);
-			}
-			return mediaEngine.fetchMediaSegment(segmentId, mediaEngine.getVideoRendition(), signal);
-		}
-	});
-};
-export { makeVideoSegmentFetchTask };

package/dist/elements/EFMedia/videoTasks/makeVideoSegmentIdTask.browsertest.d.ts

@@ -1,9 +0,0 @@
-import { EFVideo } from '../../EFVideo';
-declare class TestMediaVideoSegment extends EFVideo {
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        "test-media-video-segment": TestMediaVideoSegment;
-    }
-}
-export {};

package/dist/elements/EFMedia/videoTasks/makeVideoSegmentIdTask.d.ts

@@ -1,4 +0,0 @@
-import { Task } from '@lit/task';
-import { MediaEngine } from '../../../transcoding/types';
-import { EFVideo } from '../../EFVideo';
-export declare const makeVideoSegmentIdTask: (host: EFVideo) => Task<readonly [MediaEngine | undefined, number], number | undefined>;

package/src/elements/EFMedia/tasks/makeMediaEngineTask.test.ts

@@ -1,233 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { EFMedia } from "../../EFMedia";
-import { AssetIdMediaEngine } from "../AssetIdMediaEngine";
-import { AssetMediaEngine } from "../AssetMediaEngine";
-import { JitMediaEngine } from "../JitMediaEngine";
-import { createMediaEngine } from "./makeMediaEngineTask";
-
-// Mock the engine classes
-vi.mock("../AssetIdMediaEngine", () => ({
-  AssetIdMediaEngine: {
-    fetchByAssetId: vi.fn(),
-  },
-}));
-vi.mock("../AssetMediaEngine");
-vi.mock("../JitMediaEngine");
-
-describe("makeMediaEngineTask", () => {
-  const mockUrlGenerator = {
-    generateManifestUrl: vi.fn(),
-  };
-
-  const createMockHost = (overrides: Partial<EFMedia> = {}): EFMedia =>
-    ({
-      src: "",
-      assetId: null,
-      apiHost: "https://api.example.com",
-      urlGenerator: mockUrlGenerator,
-      ...overrides,
-    }) as EFMedia;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("createMediaEngine", () => {
-    it("should use AssetIdMediaEngine when assetId is provided", async () => {
-      const mockEngine = { durationMs: 15000 };
-      vi.mocked(AssetIdMediaEngine.fetchByAssetId).mockResolvedValue(
-        mockEngine as any,
-      );
-
-      const host = createMockHost({
-        assetId: "test-asset-123",
-        apiHost: "https://api.example.com",
-      });
-
-      const result = await createMediaEngine(host);
-
-      expect(AssetIdMediaEngine.fetchByAssetId).toHaveBeenCalledWith(
-        host,
-        mockUrlGenerator,
-        "test-asset-123",
-        "https://api.example.com",
-      );
-      expect(result).toBe(mockEngine);
-    });
-
-    it("should throw error when assetId is provided but apiHost is missing", async () => {
-      const host = createMockHost({
-        assetId: "test-asset-123",
-        apiHost: undefined,
-      });
-
-      await expect(createMediaEngine(host)).rejects.toThrow(
-        "API host is required for AssetID mode",
-      );
-    });
-
-    it("should ignore empty assetId and use src instead", async () => {
-      const mockEngine = { durationMs: 15000 };
-      vi.mocked(AssetMediaEngine.fetch).mockResolvedValue(mockEngine as any);
-
-      const host = createMockHost({
-        assetId: "",
-        src: "/path/to/asset",
-      });
-
-      const result = await createMediaEngine(host);
-
-      expect(AssetMediaEngine.fetch).toHaveBeenCalledWith(
-        host,
-        mockUrlGenerator,
-        "/path/to/asset",
-      );
-      expect(AssetIdMediaEngine.fetchByAssetId).not.toHaveBeenCalled();
-      expect(result).toBe(mockEngine);
-    });
-
-    it("should ignore whitespace-only assetId and use src instead", async () => {
-      const mockEngine = { durationMs: 15000 };
-      vi.mocked(AssetMediaEngine.fetch).mockResolvedValue(mockEngine as any);
-
-      const host = createMockHost({
-        assetId: "   ",
-        src: "/path/to/asset",
-      });
-
-      const result = await createMediaEngine(host);
-
-      expect(AssetMediaEngine.fetch).toHaveBeenCalledWith(
-        host,
-        mockUrlGenerator,
-        "/path/to/asset",
-      );
-      expect(AssetIdMediaEngine.fetchByAssetId).not.toHaveBeenCalled();
-      expect(result).toBe(mockEngine);
-    });
-
-    it("should use JitMediaEngine for HTTP URLs", async () => {
-      const mockEngine = { durationMs: 15000 };
-      const manifestUrl = "https://api.example.com/manifest.json";
-
-      vi.mocked(mockUrlGenerator.generateManifestUrl).mockReturnValue(
-        manifestUrl,
-      );
-      vi.mocked(JitMediaEngine.fetch).mockResolvedValue(mockEngine as any);
-
-      const host = createMockHost({
-        src: "https://example.com/video.mp4",
-      });
-
-      const result = await createMediaEngine(host);
-
-      expect(mockUrlGenerator.generateManifestUrl).toHaveBeenCalledWith(
-        "https://example.com/video.mp4",
-      );
-      expect(JitMediaEngine.fetch).toHaveBeenCalledWith(
-        host,
-        mockUrlGenerator,
-        manifestUrl,
-      );
-      expect(result).toBe(mockEngine);
-    });
-
-    it("should use JitMediaEngine for HTTPS URLs", async () => {
-      const mockEngine = { durationMs: 15000 };
-      const manifestUrl = "https://api.example.com/manifest.json";
-
-      vi.mocked(mockUrlGenerator.generateManifestUrl).mockReturnValue(
-        manifestUrl,
-      );
-      vi.mocked(JitMediaEngine.fetch).mockResolvedValue(mockEngine as any);
-
-      const host = createMockHost({
-        src: "https://example.com/video.mp4",
-      });
-
-      const result = await createMediaEngine(host);
-
-      expect(JitMediaEngine.fetch).toHaveBeenCalledWith(
-        host,
-        mockUrlGenerator,
-        manifestUrl,
-      );
-      expect(result).toBe(mockEngine);
-    });
-
-    it("should use AssetMediaEngine for local paths", async () => {
-      const mockEngine = { durationMs: 15000 };
-      vi.mocked(AssetMediaEngine.fetch).mockResolvedValue(mockEngine as any);
-
-      const host = createMockHost({
-        src: "/local/asset.mp4",
-      });
-
-      const result = await createMediaEngine(host);
-
-      expect(AssetMediaEngine.fetch).toHaveBeenCalledWith(
-        host,
-        mockUrlGenerator,
-        "/local/asset.mp4",
-      );
-      expect(result).toBe(mockEngine);
-    });
-
-    it("should throw error for empty src when no assetId", async () => {
-      const host = createMockHost({
-        src: "",
-        assetId: null,
-      });
-
-      await expect(createMediaEngine(host)).rejects.toThrow(
-        "Unsupported media source",
-      );
-    });
-
-    it("should throw error for whitespace-only src when no assetId", async () => {
-      const host = createMockHost({
-        src: "   ",
-        assetId: null,
-      });
-
-      await expect(createMediaEngine(host)).rejects.toThrow(
-        "Unsupported media source",
-      );
-    });
-
-    it("should throw error for null src when no assetId", async () => {
-      const host = createMockHost({
-        src: null as any,
-        assetId: null,
-      });
-
-      await expect(createMediaEngine(host)).rejects.toThrow(
-        "Unsupported media source",
-      );
-    });
-
-    it("should prioritize assetId over src when both are provided", async () => {
-      const mockEngine = { durationMs: 15000 };
-      vi.mocked(AssetIdMediaEngine.fetchByAssetId).mockResolvedValue(
-        mockEngine as any,
-      );
-
-      const host = createMockHost({
-        assetId: "test-asset-123",
-        src: "/local/asset.mp4",
-        apiHost: "https://api.example.com",
-      });
-
-      const result = await createMediaEngine(host);
-
-      expect(AssetIdMediaEngine.fetchByAssetId).toHaveBeenCalledWith(
-        host,
-        mockUrlGenerator,
-        "test-asset-123",
-        "https://api.example.com",
-      );
-      expect(AssetMediaEngine.fetch).not.toHaveBeenCalled();
-      expect(result).toBe(mockEngine);
-    });
-  });
-});