@editframe/elements 0.26.3-beta.0 → 0.30.0-beta.13

package/src/transcoding/cache/RequestDeduplicator.test.ts

@@ -1,170 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { RequestDeduplicator } from "./RequestDeduplicator.js";
-
-describe("RequestDeduplicator", () => {
-  let deduplicator: RequestDeduplicator;
-
-  beforeEach(() => {
-    deduplicator = new RequestDeduplicator();
-  });
-
-  describe("executeRequest", () => {
-    it("should execute request and return result for new key", async () => {
-      const mockFactory = vi.fn().mockResolvedValue("result");
-
-      const result = await deduplicator.executeRequest("key1", mockFactory);
-
-      expect(result).toBe("result");
-      expect(mockFactory).toHaveBeenCalledTimes(1);
-    });
-
-    it("should return same promise for concurrent requests with same key", async () => {
-      const mockFactory = vi.fn().mockResolvedValue("result");
-
-      const [result1, result2] = await Promise.all([
-        deduplicator.executeRequest("key1", mockFactory),
-        deduplicator.executeRequest("key1", mockFactory),
-      ]);
-
-      expect(result1).toBe("result");
-      expect(result2).toBe("result");
-      expect(mockFactory).toHaveBeenCalledTimes(1); // Should only be called once
-    });
-
-    it("should allow separate requests for different keys", async () => {
-      const mockFactory1 = vi.fn().mockResolvedValue("result1");
-      const mockFactory2 = vi.fn().mockResolvedValue("result2");
-
-      const [result1, result2] = await Promise.all([
-        deduplicator.executeRequest("key1", mockFactory1),
-        deduplicator.executeRequest("key2", mockFactory2),
-      ]);
-
-      expect(result1).toBe("result1");
-      expect(result2).toBe("result2");
-      expect(mockFactory1).toHaveBeenCalledTimes(1);
-      expect(mockFactory2).toHaveBeenCalledTimes(1);
-    });
-
-    it("should handle request failures and clean up", async () => {
-      const error = new Error("Request failed");
-      const mockFactory = vi.fn().mockRejectedValue(error);
-
-      await expect(
-        deduplicator.executeRequest("key1", mockFactory),
-      ).rejects.toThrow("Request failed");
-
-      // Should allow new request with same key after failure
-      const mockFactory2 = vi.fn().mockResolvedValue("success");
-      const result = await deduplicator.executeRequest("key1", mockFactory2);
-
-      expect(result).toBe("success");
-      expect(mockFactory).toHaveBeenCalledTimes(1);
-      expect(mockFactory2).toHaveBeenCalledTimes(1);
-    });
-
-    it("should clean up pending requests after success", async () => {
-      const mockFactory = vi.fn().mockResolvedValue("result");
-
-      await deduplicator.executeRequest("key1", mockFactory);
-
-      expect(deduplicator.isPending("key1")).toBe(false);
-      expect(deduplicator.getPendingCount()).toBe(0);
-    });
-  });
-
-  describe("isPending", () => {
-    it("should return true for pending requests", async () => {
-      const mockFactory = vi.fn().mockImplementation(
-        () =>
-          new Promise((resolve) => {
-            setTimeout(() => resolve("result"), 100);
-          }),
-      );
-
-      const promise = deduplicator.executeRequest("key1", mockFactory);
-
-      expect(deduplicator.isPending("key1")).toBe(true);
-
-      await promise;
-
-      expect(deduplicator.isPending("key1")).toBe(false);
-    });
-
-    it("should return false for non-existent keys", () => {
-      expect(deduplicator.isPending("nonexistent")).toBe(false);
-    });
-  });
-
-  describe("getPendingCount", () => {
-    it("should return 0 initially", () => {
-      expect(deduplicator.getPendingCount()).toBe(0);
-    });
-
-    it("should track pending request count", async () => {
-      const mockFactory = vi.fn().mockImplementation(
-        () =>
-          new Promise((resolve) => {
-            setTimeout(() => resolve("result"), 100);
-          }),
-      );
-
-      const promise1 = deduplicator.executeRequest("key1", mockFactory);
-      const promise2 = deduplicator.executeRequest("key2", mockFactory);
-
-      expect(deduplicator.getPendingCount()).toBe(2);
-
-      await Promise.all([promise1, promise2]);
-
-      expect(deduplicator.getPendingCount()).toBe(0);
-    });
-  });
-
-  describe("getPendingKeys", () => {
-    it("should return empty array initially", () => {
-      expect(deduplicator.getPendingKeys()).toEqual([]);
-    });
-
-    it("should return pending keys", async () => {
-      const mockFactory = vi.fn().mockImplementation(
-        () =>
-          new Promise((resolve) => {
-            setTimeout(() => resolve("result"), 100);
-          }),
-      );
-
-      const promise1 = deduplicator.executeRequest("key1", mockFactory);
-      const promise2 = deduplicator.executeRequest("key2", mockFactory);
-
-      const pendingKeys = deduplicator.getPendingKeys();
-      expect(pendingKeys).toHaveLength(2);
-      expect(pendingKeys).toContain("key1");
-      expect(pendingKeys).toContain("key2");
-
-      await Promise.all([promise1, promise2]);
-
-      expect(deduplicator.getPendingKeys()).toEqual([]);
-    });
-  });
-
-  describe("clear", () => {
-    it("should clear all pending requests", async () => {
-      const mockFactory = vi.fn().mockImplementation(
-        () =>
-          new Promise((resolve) => {
-            setTimeout(() => resolve("result"), 100);
-          }),
-      );
-
-      deduplicator.executeRequest("key1", mockFactory);
-      deduplicator.executeRequest("key2", mockFactory);
-
-      expect(deduplicator.getPendingCount()).toBe(2);
-
-      deduplicator.clear();
-
-      expect(deduplicator.getPendingCount()).toBe(0);
-      expect(deduplicator.getPendingKeys()).toEqual([]);
-    });
-  });
-});

package/src/transcoding/cache/RequestDeduplicator.ts

@@ -1,65 +0,0 @@
-/**
- * Request deduplication utility
- * Manages pending requests to prevent concurrent duplicate requests
- */
-
-export class RequestDeduplicator {
-  private pendingRequests = new Map<string, Promise<any>>();
-
-  /**
-   * Execute a request with deduplication
-   * If a request with the same key is already pending, return the existing promise
-   * Otherwise, execute the request factory and track the promise
-   */
-  async executeRequest<T>(
-    key: string,
-    requestFactory: () => Promise<T>,
-  ): Promise<T> {
-    // Check if there's already a pending request for this key
-    const existingRequest = this.pendingRequests.get(key);
-    if (existingRequest) {
-      return existingRequest;
-    }
-
-    // Create and track the new request
-    const requestPromise = requestFactory();
-    this.pendingRequests.set(key, requestPromise);
-
-    try {
-      const result = await requestPromise;
-      this.pendingRequests.delete(key);
-      return result;
-    } catch (error) {
-      this.pendingRequests.delete(key);
-      throw error;
-    }
-  }
-
-  /**
-   * Clear all pending requests (used in cache clearing)
-   */
-  clear(): void {
-    this.pendingRequests.clear();
-  }
-
-  /**
-   * Get number of pending requests
-   */
-  getPendingCount(): number {
-    return this.pendingRequests.size;
-  }
-
-  /**
-   * Check if a request is pending
-   */
-  isPending(key: string): boolean {
-    return this.pendingRequests.has(key);
-  }
-
-  /**
-   * Get all pending request keys
-   */
-  getPendingKeys(): string[] {
-    return Array.from(this.pendingRequests.keys());
-  }
-}

package/src/transcoding/cache/URLTokenDeduplicator.test.ts

@@ -1,182 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { URLTokenDeduplicator } from "./URLTokenDeduplicator.js";
-
-describe("URLTokenDeduplicator", () => {
-  let deduplicator: URLTokenDeduplicator;
-
-  beforeEach(() => {
-    deduplicator = new URLTokenDeduplicator();
-    vi.useFakeTimers();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("should deduplicate concurrent requests for same cache key", async () => {
-    const mockTokenFactory = vi.fn().mockResolvedValue("test-token");
-    const mockParseExpiration = vi.fn().mockReturnValue(Date.now() + 60000);
-
-    // Make 3 concurrent requests for the same cache key
-    const promises = [
-      deduplicator.getToken("key1", mockTokenFactory, mockParseExpiration),
-      deduplicator.getToken("key1", mockTokenFactory, mockParseExpiration),
-      deduplicator.getToken("key1", mockTokenFactory, mockParseExpiration),
-    ];
-
-    const results = await Promise.all(promises);
-
-    // All should return the same token
-    expect(results).toEqual(["test-token", "test-token", "test-token"]);
-
-    // Factory should only be called once due to deduplication
-    expect(mockTokenFactory).toHaveBeenCalledTimes(1);
-    expect(mockParseExpiration).toHaveBeenCalledTimes(1);
-  });
-
-  it("should use separate tokens for different cache keys", async () => {
-    const mockTokenFactory1 = vi.fn().mockResolvedValue("token1");
-    const mockTokenFactory2 = vi.fn().mockResolvedValue("token2");
-    const mockParseExpiration = vi.fn().mockReturnValue(Date.now() + 60000);
-
-    const [token1, token2] = await Promise.all([
-      deduplicator.getToken("key1", mockTokenFactory1, mockParseExpiration),
-      deduplicator.getToken("key2", mockTokenFactory2, mockParseExpiration),
-    ]);
-
-    expect(token1).toBe("token1");
-    expect(token2).toBe("token2");
-    expect(mockTokenFactory1).toHaveBeenCalledTimes(1);
-    expect(mockTokenFactory2).toHaveBeenCalledTimes(1);
-  });
-
-  it("should reuse cached tokens that haven't expired", async () => {
-    const futureTime = Date.now() + 60000;
-    const mockTokenFactory = vi.fn().mockResolvedValue("cached-token");
-    const mockParseExpiration = vi.fn().mockReturnValue(futureTime);
-
-    // First request
-    const token1 = await deduplicator.getToken(
-      "key1",
-      mockTokenFactory,
-      mockParseExpiration,
-    );
-
-    // Second request for same key should reuse cached token
-    const token2 = await deduplicator.getToken(
-      "key1",
-      vi.fn(),
-      mockParseExpiration,
-    );
-
-    expect(token1).toBe("cached-token");
-    expect(token2).toBe("cached-token");
-    expect(mockTokenFactory).toHaveBeenCalledTimes(1);
-  });
-
-  it("should fetch new token when cached token is expired", async () => {
-    const pastTime = Date.now() - 1000; // Expired 1 second ago
-    const futureTime = Date.now() + 60000; // New token expires in 1 minute
-
-    const mockTokenFactory1 = vi.fn().mockResolvedValue("expired-token");
-    const mockTokenFactory2 = vi.fn().mockResolvedValue("fresh-token");
-    const mockParseExpiration1 = vi.fn().mockReturnValue(pastTime);
-    const mockParseExpiration2 = vi.fn().mockReturnValue(futureTime);
-
-    // First request with expired token
-    await deduplicator.getToken(
-      "key1",
-      mockTokenFactory1,
-      mockParseExpiration1,
-    );
-
-    // Advance time to simulate token expiration
-    vi.advanceTimersByTime(2000);
-
-    // Second request should fetch new token due to expiration
-    const token2 = await deduplicator.getToken(
-      "key1",
-      mockTokenFactory2,
-      mockParseExpiration2,
-    );
-
-    expect(token2).toBe("fresh-token");
-    expect(mockTokenFactory1).toHaveBeenCalledTimes(1);
-    expect(mockTokenFactory2).toHaveBeenCalledTimes(1);
-  });
-
-  it("should handle token factory errors by removing from cache", async () => {
-    const mockTokenFactory1 = vi
-      .fn()
-      .mockRejectedValue(new Error("Network error"));
-    const mockTokenFactory2 = vi.fn().mockResolvedValue("retry-token");
-    const mockParseExpiration = vi.fn().mockReturnValue(Date.now() + 60000);
-
-    // First request fails
-    await expect(
-      deduplicator.getToken("key1", mockTokenFactory1, mockParseExpiration),
-    ).rejects.toThrow("Network error");
-
-    // Retry should work and not be blocked by failed request
-    const token = await deduplicator.getToken(
-      "key1",
-      mockTokenFactory2,
-      mockParseExpiration,
-    );
-
-    expect(token).toBe("retry-token");
-    expect(mockTokenFactory1).toHaveBeenCalledTimes(1);
-    expect(mockTokenFactory2).toHaveBeenCalledTimes(1);
-  });
-
-  it("should provide utility methods for cache management", () => {
-    const mockParseExpiration = vi.fn().mockReturnValue(Date.now() + 60000);
-
-    expect(deduplicator.getCachedCount()).toBe(0);
-    expect(deduplicator.getCachedKeys()).toEqual([]);
-    expect(deduplicator.hasValidToken("nonexistent")).toBe(false);
-
-    // Add a token to cache
-    deduplicator.getToken(
-      "key1",
-      vi.fn().mockResolvedValue("token"),
-      mockParseExpiration,
-    );
-
-    expect(deduplicator.getCachedCount()).toBe(1);
-    expect(deduplicator.getCachedKeys()).toEqual(["key1"]);
-    expect(deduplicator.hasValidToken("key1")).toBe(true);
-
-    // Clear cache
-    deduplicator.clear();
-    expect(deduplicator.getCachedCount()).toBe(0);
-  });
-
-  it("should cleanup expired tokens", async () => {
-    const pastTime = Date.now() - 1000;
-    const futureTime = Date.now() + 60000;
-
-    const mockParseExpiration1 = vi.fn().mockReturnValue(pastTime);
-    const mockParseExpiration2 = vi.fn().mockReturnValue(futureTime);
-
-    // Add expired and valid tokens
-    await deduplicator.getToken(
-      "expired",
-      vi.fn().mockResolvedValue("token1"),
-      mockParseExpiration1,
-    );
-    await deduplicator.getToken(
-      "valid",
-      vi.fn().mockResolvedValue("token2"),
-      mockParseExpiration2,
-    );
-
-    expect(deduplicator.getCachedCount()).toBe(2);
-
-    // Cleanup should remove expired tokens
-    deduplicator.cleanup();
-
-    expect(deduplicator.getCachedCount()).toBe(1);
-    expect(deduplicator.getCachedKeys()).toEqual(["valid"]);
-  });
-});

package/src/transcoding/cache/URLTokenDeduplicator.ts

@@ -1,101 +0,0 @@
-/**
- * Global URL token deduplication utility
- * Ensures that multiple EFMedia elements requesting tokens for the same resource
- * share a single token request, preventing unnecessary duplicate token generation
- */
-
-export interface TokenCacheEntry {
-  tokenPromise: Promise<string>;
-  expiration: number;
-}
-
-export class URLTokenDeduplicator {
-  private tokenCache = new Map<string, TokenCacheEntry>();
-
-  /**
-   * Get or create a URL token with global deduplication
-   * Multiple requests for the same cache key will share the same token promise
-   */
-  async getToken(
-    cacheKey: string,
-    tokenFactory: () => Promise<string>,
-    parseExpiration: (token: string) => number,
-  ): Promise<string> {
-    const now = Date.now();
-    const cached = this.tokenCache.get(cacheKey);
-
-    // Check if we have a valid cached token
-    if (cached && now < cached.expiration) {
-      return cached.tokenPromise;
-    }
-
-    // Create new token request
-    const tokenPromise = tokenFactory()
-      .then(async (token) => {
-        // Update expiration after we get the token
-        const expiration = parseExpiration(token);
-        this.tokenCache.set(cacheKey, { tokenPromise, expiration });
-        return token;
-      })
-      .catch((error) => {
-        // Remove failed request from cache
-        this.tokenCache.delete(cacheKey);
-        throw error;
-      });
-
-    // Cache the promise immediately to deduplicate concurrent requests
-    this.tokenCache.set(cacheKey, {
-      tokenPromise,
-      expiration: now + 60000, // Temporary 1-minute expiration, will be updated when token is received
-    });
-
-    return tokenPromise;
-  }
-
-  /**
-   * Clear all cached tokens (used in testing)
-   */
-  clear(): void {
-    this.tokenCache.clear();
-  }
-
-  /**
-   * Get number of cached tokens
-   */
-  getCachedCount(): number {
-    return this.tokenCache.size;
-  }
-
-  /**
-   * Check if a token is cached and valid
-   */
-  hasValidToken(cacheKey: string): boolean {
-    const cached = this.tokenCache.get(cacheKey);
-    if (!cached) return false;
-
-    const now = Date.now();
-    return now < cached.expiration;
-  }
-
-  /**
-   * Get all cached token keys
-   */
-  getCachedKeys(): string[] {
-    return Array.from(this.tokenCache.keys());
-  }
-
-  /**
-   * Remove expired tokens from cache
-   */
-  cleanup(): void {
-    const now = Date.now();
-    for (const [key, entry] of this.tokenCache.entries()) {
-      if (now >= entry.expiration) {
-        this.tokenCache.delete(key);
-      }
-    }
-  }
-}
-
-// Global instance shared across all context providers
-export const globalURLTokenDeduplicator = new URLTokenDeduplicator();