recker 1.0.79 → 1.0.80-next.70ea84d

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

@@ -1,381 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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;
-    trace(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
-        times?: number;
-    }): this;
-    connect(path: string, handler: MockHttpResponse | MockHttpHandler, options?: {
-        times?: number;
-    }): this;
-    purge(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>;
-export interface WebhookServerOptions extends MockHttpServerOptions {
-    log?: boolean;
-    logger?: (webhook: WebhookPayload) => void;
-    status?: 200 | 204;
-}
-export interface WebhookPayload {
-    id: string | null;
-    timestamp: Date;
-    method: string;
-    path: string;
-    headers: Record<string, string | string[] | undefined>;
-    body: any;
-}
-export declare function createWebhookServer(options?: WebhookServerOptions): Promise<MockHttpServer & {
-    webhooks: WebhookPayload[];
-}>;