recker 1.0.20-next.de24f7d → 1.0.20-next.e194d90

package/dist/testing/mock-hls-server.js

@@ -0,0 +1,381 @@
+import { EventEmitter } from 'node:events';
+const DEFAULT_VARIANTS = [
+    { name: '360p', bandwidth: 800_000, resolution: '640x360', codecs: 'avc1.4d401e,mp4a.40.2' },
+    { name: '480p', bandwidth: 1_400_000, resolution: '854x480', codecs: 'avc1.4d401e,mp4a.40.2' },
+    { name: '720p', bandwidth: 2_800_000, resolution: '1280x720', codecs: 'avc1.4d401f,mp4a.40.2' },
+    { name: '1080p', bandwidth: 5_000_000, resolution: '1920x1080', codecs: 'avc1.640028,mp4a.40.2' },
+];
+export class MockHlsServer extends EventEmitter {
+    options;
+    segments = new Map();
+    currentSequence;
+    ended = false;
+    started = false;
+    realtimeInterval = null;
+    startTime = 0;
+    stats = {
+        playlistRequests: 0,
+        segmentRequests: 0,
+        segmentsServed: 0,
+        bytesServed: 0,
+        requestLog: [],
+    };
+    constructor(options = {}) {
+        super();
+        const segmentDuration = options.segmentDuration ?? 6;
+        this.options = {
+            mode: 'vod',
+            segmentDuration,
+            segmentCount: 10,
+            windowSize: 3,
+            startSequence: 0,
+            realtime: false,
+            segmentInterval: segmentDuration * 1000,
+            multiQuality: false,
+            variants: options.variants ?? DEFAULT_VARIANTS,
+            encrypted: false,
+            baseUrl: 'http://mock-hls-server',
+            delay: 0,
+            segmentDataGenerator: options.segmentDataGenerator ?? this.defaultSegmentGenerator.bind(this),
+            ...options,
+        };
+        this.currentSequence = this.options.startSequence;
+    }
+    get isRunning() {
+        return this.started && !this.ended;
+    }
+    get isEnded() {
+        return this.ended;
+    }
+    get manifestUrl() {
+        return this.options.multiQuality
+            ? `${this.options.baseUrl}/master.m3u8`
+            : `${this.options.baseUrl}/playlist.m3u8`;
+    }
+    get segmentCount() {
+        const variantKey = this.options.multiQuality ? this.options.variants[0].name : 'default';
+        return this.segments.get(variantKey)?.length ?? 0;
+    }
+    get statistics() {
+        return { ...this.stats };
+    }
+    get transport() {
+        return {
+            dispatch: async (req) => this.handleRequest(req),
+        };
+    }
+    async start() {
+        if (this.started) {
+            throw new Error('Server already started');
+        }
+        this.started = true;
+        this.startTime = Date.now();
+        if (this.options.mode === 'vod') {
+            this.initializeVodSegments();
+        }
+        else {
+            this.initializeLiveSegments();
+            if (this.options.realtime) {
+                this.startRealtimeSegmentGeneration();
+            }
+        }
+        this.emit('start');
+    }
+    async stop() {
+        if (!this.started)
+            return;
+        if (this.realtimeInterval) {
+            clearInterval(this.realtimeInterval);
+            this.realtimeInterval = null;
+        }
+        this.started = false;
+        this.emit('stop');
+    }
+    endStream() {
+        if (this.options.mode === 'vod')
+            return;
+        this.ended = true;
+        if (this.realtimeInterval) {
+            clearInterval(this.realtimeInterval);
+            this.realtimeInterval = null;
+        }
+        this.emit('ended');
+    }
+    reset() {
+        this.segments.clear();
+        this.currentSequence = this.options.startSequence;
+        this.ended = false;
+        this.stats = {
+            playlistRequests: 0,
+            segmentRequests: 0,
+            segmentsServed: 0,
+            bytesServed: 0,
+            requestLog: [],
+        };
+        if (this.started) {
+            if (this.options.mode === 'vod') {
+                this.initializeVodSegments();
+            }
+            else {
+                this.initializeLiveSegments();
+            }
+        }
+        this.emit('reset');
+    }
+    addSegment(variant = 'default', options = {}) {
+        const variantSegments = this.segments.get(variant) ?? [];
+        const segment = {
+            sequence: this.currentSequence,
+            duration: this.options.segmentDuration,
+            data: options.data ?? this.options.segmentDataGenerator(this.currentSequence, variant),
+            addedAt: Date.now(),
+            programDateTime: options.programDateTime,
+            discontinuity: options.discontinuity,
+            ...options,
+        };
+        variantSegments.push(segment);
+        this.segments.set(variant, variantSegments);
+        this.currentSequence++;
+        if (this.options.mode === 'live' && variantSegments.length > this.options.windowSize) {
+            variantSegments.shift();
+        }
+        this.emit('segment', segment, variant);
+        return segment;
+    }
+    addDiscontinuity(variant = 'default') {
+        this.addSegment(variant, { discontinuity: true });
+    }
+    getSegments(variant = 'default') {
+        return [...(this.segments.get(variant) ?? [])];
+    }
+    async handleRequest(req) {
+        const url = req.url;
+        this.stats.requestLog.push({ url, timestamp: Date.now() });
+        if (this.options.delay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, this.options.delay));
+        }
+        if (url.includes('master.m3u8')) {
+            return this.handleMasterPlaylist();
+        }
+        if (url.includes('.m3u8')) {
+            return this.handleMediaPlaylist(url);
+        }
+        if (url.includes('.ts')) {
+            return this.handleSegment(url);
+        }
+        if (url.includes('.key')) {
+            return this.handleKey();
+        }
+        throw new Error(`Unknown request: ${url}`);
+    }
+    handleMasterPlaylist() {
+        this.stats.playlistRequests++;
+        const lines = ['#EXTM3U', '#EXT-X-VERSION:3'];
+        for (const variant of this.options.variants) {
+            const attrs = [
+                `BANDWIDTH=${variant.bandwidth}`,
+                variant.resolution ? `RESOLUTION=${variant.resolution}` : null,
+                variant.codecs ? `CODECS="${variant.codecs}"` : null,
+                `NAME="${variant.name}"`,
+            ]
+                .filter(Boolean)
+                .join(',');
+            lines.push(`#EXT-X-STREAM-INF:${attrs}`);
+            lines.push(`${variant.name}/playlist.m3u8`);
+        }
+        const body = lines.join('\n');
+        return this.createResponse(body, 'application/vnd.apple.mpegurl');
+    }
+    handleMediaPlaylist(url) {
+        this.stats.playlistRequests++;
+        let variant = 'default';
+        if (this.options.multiQuality) {
+            const match = url.match(/\/(\w+)\/playlist\.m3u8/);
+            variant = match?.[1] ?? this.options.variants[0].name;
+        }
+        if (this.options.mode === 'live' && !this.options.realtime && !this.ended) {
+            this.addSegmentToAllVariants();
+        }
+        const segments = this.segments.get(variant) ?? [];
+        const lines = [
+            '#EXTM3U',
+            '#EXT-X-VERSION:3',
+            `#EXT-X-TARGETDURATION:${Math.ceil(this.options.segmentDuration)}`,
+        ];
+        if (this.options.mode !== 'vod') {
+            const mediaSequence = segments.length > 0 ? segments[0].sequence : 0;
+            lines.push(`#EXT-X-MEDIA-SEQUENCE:${mediaSequence}`);
+        }
+        if (this.options.mode === 'event') {
+            lines.push('#EXT-X-PLAYLIST-TYPE:EVENT');
+        }
+        else if (this.options.mode === 'vod') {
+            lines.push('#EXT-X-PLAYLIST-TYPE:VOD');
+        }
+        if (this.options.encrypted) {
+            lines.push(`#EXT-X-KEY:METHOD=AES-128,URI="${this.options.baseUrl}/key.key",IV=0x00000000000000000000000000000001`);
+        }
+        for (const segment of segments) {
+            if (segment.discontinuity) {
+                lines.push('#EXT-X-DISCONTINUITY');
+            }
+            if (segment.programDateTime) {
+                lines.push(`#EXT-X-PROGRAM-DATE-TIME:${segment.programDateTime.toISOString()}`);
+            }
+            lines.push(`#EXTINF:${segment.duration.toFixed(3)},`);
+            const segmentPath = this.options.multiQuality
+                ? `${variant}/segment${segment.sequence}.ts`
+                : `segment${segment.sequence}.ts`;
+            lines.push(segmentPath);
+        }
+        if (this.options.mode === 'vod' || this.ended) {
+            lines.push('#EXT-X-ENDLIST');
+        }
+        const body = lines.join('\n');
+        return this.createResponse(body, 'application/vnd.apple.mpegurl');
+    }
+    handleSegment(url) {
+        this.stats.segmentRequests++;
+        const urlPath = url.replace(/^https?:\/\/[^/]+/, '');
+        const match = urlPath.match(/(?:\/(\w+))?\/segment(\d+)\.ts/);
+        if (!match) {
+            return this.createResponse('Not Found', 'text/plain', 404);
+        }
+        const variant = match[1] ?? 'default';
+        const sequence = parseInt(match[2], 10);
+        const segments = this.segments.get(variant) ?? [];
+        const segment = segments.find((s) => s.sequence === sequence);
+        if (!segment) {
+            return this.createResponse('Not Found', 'text/plain', 404);
+        }
+        this.stats.segmentsServed++;
+        this.stats.bytesServed += segment.data.byteLength;
+        this.emit('segmentServed', segment, variant);
+        return this.createResponse(segment.data, 'video/mp2t');
+    }
+    handleKey() {
+        const key = new Uint8Array(16);
+        for (let i = 0; i < 16; i++) {
+            key[i] = i;
+        }
+        return this.createResponse(key, 'application/octet-stream');
+    }
+    createResponse(body, contentType, status = 200) {
+        const isText = typeof body === 'string';
+        const blobData = isText ? body : new Uint8Array(body);
+        return {
+            ok: status >= 200 && status < 300,
+            status,
+            text: async () => (isText ? body : new TextDecoder().decode(body)),
+            blob: async () => new Blob([blobData]),
+            arrayBuffer: async () => (isText ? new TextEncoder().encode(body).buffer : body.buffer),
+            headers: new Headers({
+                'content-type': contentType,
+                'content-length': String(isText ? body.length : body.byteLength),
+            }),
+        };
+    }
+    initializeVodSegments() {
+        const variants = this.options.multiQuality
+            ? this.options.variants.map((v) => v.name)
+            : ['default'];
+        for (const variant of variants) {
+            this.segments.set(variant, []);
+            for (let i = 0; i < this.options.segmentCount; i++) {
+                const segment = {
+                    sequence: this.currentSequence,
+                    duration: this.options.segmentDuration,
+                    data: this.options.segmentDataGenerator(this.currentSequence, variant),
+                    addedAt: Date.now(),
+                };
+                this.segments.get(variant).push(segment);
+                this.currentSequence++;
+            }
+            if (this.options.multiQuality) {
+                this.currentSequence = this.options.startSequence;
+            }
+        }
+        this.currentSequence = this.options.startSequence + this.options.segmentCount;
+    }
+    initializeLiveSegments() {
+        const variants = this.options.multiQuality
+            ? this.options.variants.map((v) => v.name)
+            : ['default'];
+        for (const variant of variants) {
+            this.segments.set(variant, []);
+            for (let i = 0; i < this.options.windowSize; i++) {
+                const segment = {
+                    sequence: this.currentSequence + i,
+                    duration: this.options.segmentDuration,
+                    data: this.options.segmentDataGenerator(this.currentSequence + i, variant),
+                    addedAt: Date.now(),
+                };
+                this.segments.get(variant).push(segment);
+            }
+        }
+        this.currentSequence += this.options.windowSize;
+    }
+    addSegmentToAllVariants() {
+        const variants = this.options.multiQuality
+            ? this.options.variants.map((v) => v.name)
+            : ['default'];
+        for (const variant of variants) {
+            const variantSegments = this.segments.get(variant) ?? [];
+            const segment = {
+                sequence: this.currentSequence,
+                duration: this.options.segmentDuration,
+                data: this.options.segmentDataGenerator(this.currentSequence, variant),
+                addedAt: Date.now(),
+            };
+            variantSegments.push(segment);
+            if (this.options.mode === 'live' && variantSegments.length > this.options.windowSize) {
+                variantSegments.shift();
+            }
+            this.segments.set(variant, variantSegments);
+            this.emit('segment', segment, variant);
+        }
+        this.currentSequence++;
+    }
+    startRealtimeSegmentGeneration() {
+        this.realtimeInterval = setInterval(() => {
+            if (this.ended)
+                return;
+            this.addSegmentToAllVariants();
+        }, this.options.segmentInterval);
+    }
+    defaultSegmentGenerator(sequence, _variant) {
+        const size = 1024 + (sequence % 512);
+        const data = new Uint8Array(size);
+        for (let i = 0; i < size; i++) {
+            data[i] = (sequence * 17 + i * 13) % 256;
+        }
+        return data;
+    }
+    static async create(options = {}) {
+        const server = new MockHlsServer(options);
+        await server.start();
+        return server;
+    }
+}
+export async function createMockHlsVod(segmentCount = 10, options = {}) {
+    return MockHlsServer.create({
+        mode: 'vod',
+        segmentCount,
+        ...options,
+    });
+}
+export async function createMockHlsLive(options = {}) {
+    return MockHlsServer.create({
+        mode: 'live',
+        realtime: true,
+        segmentDuration: 2,
+        windowSize: 3,
+        ...options,
+    });
+}
+export async function createMockHlsMultiQuality(options = {}) {
+    return MockHlsServer.create({
+        multiQuality: true,
+        ...options,
+    });
+}

package/dist/testing/mock-http-server.d.ts

@@ -0,0 +1,99 @@
+import { EventEmitter } from 'node:events';
+import { type IncomingMessage } from 'node:http';
+export interface MockHttpServerOptions {
+    port?: number;
+    host?: string;
+    defaultResponse?: MockHttpResponse;
+    delay?: number;
+    cors?: boolean;
+    corsOrigin?: string;
+}
+export interface MockHttpResponse {
+    status?: number;
+    body?: any;
+    headers?: Record<string, string>;
+    delay?: number;
+    drop?: boolean;
+    stream?: {
+        chunks: (string | Buffer)[];
+        interval: number;
+    };
+}
+export interface MockHttpRequest {
+    method: string;
+    path: string;
+    query: Record<string, string>;
+    headers: Record<string, string | string[] | undefined>;
+    body: any;
+    raw: IncomingMessage;
+}
+export type MockHttpHandler = (req: MockHttpRequest) => MockHttpResponse | Promise<MockHttpResponse>;
+export interface MockHttpStats {
+    totalRequests: number;
+    requestsByMethod: Record<string, number>;
+    requestsByPath: Record<string, number>;
+    requestLog: Array<{
+        method: string;
+        path: string;
+        status: number;
+        timestamp: number;
+        duration: number;
+    }>;
+}
+export declare class MockHttpServer extends EventEmitter {
+    private options;
+    private httpServer;
+    private routes;
+    private _port;
+    private _started;
+    private stats;
+    constructor(options?: MockHttpServerOptions);
+    get port(): number;
+    get address(): string;
+    get url(): string;
+    get isRunning(): boolean;
+    get statistics(): MockHttpStats;
+    get routeCount(): number;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    reset(): void;
+    route(method: string, path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
+        times?: number;
+    }): this;
+    get(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
+        times?: number;
+    }): this;
+    post(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
+        times?: number;
+    }): this;
+    put(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
+        times?: number;
+    }): this;
+    patch(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
+        times?: number;
+    }): this;
+    delete(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
+        times?: number;
+    }): this;
+    head(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
+        times?: number;
+    }): this;
+    optionsRoute(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
+        times?: number;
+    }): this;
+    any(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
+        times?: number;
+    }): this;
+    removeRoute(method: string, path: string): boolean;
+    clearRoutes(): void;
+    private handleRequest;
+    private findRoute;
+    private sendResponse;
+    private sendCorsHeaders;
+    private parseBody;
+    private pathToRegex;
+    waitForRequests(count: number, timeout?: number): Promise<void>;
+    getCallCount(method: string, path: string): number;
+    static create(options?: MockHttpServerOptions): Promise<MockHttpServer>;
+}
+export declare function createMockHttpServer(routes?: Record<string, MockHttpResponse>, options?: MockHttpServerOptions): Promise<MockHttpServer>;