recker 1.0.19 → 1.0.20-next.2433419

package/dist/plugins/dedup.js

@@ -1,5 +1,5 @@
 const keyBuffer = { method: '', url: '' };
-export function dedup(options = {}) {
+export function dedupPlugin(options = {}) {
     const pendingRequests = new Map();
     const generateKey = options.keyGenerator || ((req) => {
         return req.method + ':' + req.url;

package/dist/plugins/graphql.d.ts

@@ -11,4 +11,3 @@ export interface GraphQLOptions {
 }
 export declare function graphqlPlugin(options?: GraphQLOptions): Plugin;
 export declare function graphql<T = any>(client: Client, query: string, variables?: Record<string, any>, options?: any): Promise<T>;
-//# sourceMappingURL=graphql.d.ts.map

package/dist/plugins/grpc-web.d.ts

@@ -77,4 +77,3 @@ declare module '../core/client.js' {
         grpcWeb(options?: Partial<GrpcWebOptions>): GrpcWebClient;
     }
 }
-//# sourceMappingURL=grpc-web.d.ts.map

package/dist/plugins/har-player.d.ts

@@ -3,5 +3,4 @@ export interface HarPlayerOptions {
     path: string;
     strict?: boolean;
 }
-export declare function harPlayer(options: HarPlayerOptions): Plugin;
-//# sourceMappingURL=har-player.d.ts.map
+export declare function harPlayerPlugin(options: HarPlayerOptions): Plugin;

package/dist/plugins/har-player.js

@@ -1,7 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { HttpResponse } from '../core/response.js';
 import { ParseError, NotFoundError } from '../core/errors.js';
-export function harPlayer(options) {
+export function harPlayerPlugin(options) {
     let entries = [];
     try {
         const content = readFileSync(options.path, 'utf-8');

package/dist/plugins/har-recorder.d.ts

@@ -3,5 +3,4 @@ export interface HarOptions {
     path?: string;
     onEntry?: (entry: any) => void;
 }
-export declare function harRecorder(options?: HarOptions): Plugin;
-//# sourceMappingURL=har-recorder.d.ts.map
+export declare function harRecorderPlugin(options?: HarOptions): Plugin;

package/dist/plugins/har-recorder.js

@@ -1,5 +1,5 @@
 import { writeFileSync } from 'node:fs';
-export function harRecorder(options = {}) {
+export function harRecorderPlugin(options = {}) {
     const entries = [];
     const startTime = new Date().toISOString();
     return (client) => {

package/dist/plugins/hls.d.ts

@@ -1,33 +1,105 @@
-import { Client } from '../core/client.js';
-export interface Variant {
+import type { Client } from '../core/client.js';
+import { type WriteStream } from 'node:fs';
+import { Writable } from 'node:stream';
+export interface HlsVariant {
     url: string;
     bandwidth?: number;
     resolution?: string;
+    codecs?: string;
+    name?: string;
 }
-export interface Segment {
+export interface HlsSegment {
     url: string;
     duration: number;
     sequence: number;
-    key?: KeyInfo;
+    key?: HlsKeyInfo;
+    discontinuity?: boolean;
+    programDateTime?: Date;
 }
-export interface KeyInfo {
-    method: string;
+export interface HlsKeyInfo {
+    method: 'NONE' | 'AES-128' | 'SAMPLE-AES';
     uri?: string;
     iv?: string;
 }
-export interface HlsHooks {
-    onManifest?: (manifest: string, url: string) => string | void;
-    onVariantSelected?: (variants: Variant[], defaultSelected: Variant) => Variant | void;
-    onSegment?: (segment: Segment) => Segment | void | null;
-    onKey?: (key: KeyInfo) => KeyInfo | void;
+export interface HlsPlaylist {
+    segments: HlsSegment[];
+    targetDuration: number;
+    mediaSequence: number;
+    endList: boolean;
+    playlistType?: 'VOD' | 'EVENT';
+    discontinuitySequence: number;
 }
-export interface HlsOptions extends HlsHooks {
+export interface HlsMasterPlaylist {
+    variants: HlsVariant[];
+    isMaster: true;
+}
+export interface SegmentData {
+    sequence: number;
+    duration: number;
+    data: Uint8Array;
+    url: string;
+    downloadedAt: Date;
+}
+export interface HlsProgress {
+    downloadedSegments: number;
+    totalSegments?: number;
+    downloadedBytes: number;
+    currentSegment: number;
+    isLive: boolean;
+    elapsed: number;
+}
+export interface HlsOptions {
+    mode?: 'merge' | 'chunks';
+    format?: 'ts' | 'mp4' | 'mkv';
+    live?: boolean | {
+        duration: number;
+    };
+    quality?: 'highest' | 'lowest' | {
+        bandwidth?: number;
+        resolution?: string;
+    };
     concurrency?: number;
-    merge?: boolean;
-    live?: boolean;
-    duration?: number;
-    onInfo?: (message: string) => void;
+    onSegment?: (segment: SegmentData) => void | Promise<void>;
+    onProgress?: (progress: HlsProgress) => void;
     onError?: (error: Error) => void;
+    headers?: Record<string, string>;
+}
+type DownloadDest = string | ((segment: HlsSegment) => string);
+export declare class HlsPromise implements Promise<void> {
+    private client;
+    private manifestUrl;
+    private options;
+    private seenSequences;
+    private downloadedBytes;
+    private downloadedSegments;
+    private startTime;
+    private aborted;
+    private abortController;
+    constructor(client: Client, manifestUrl: string, options?: HlsOptions);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<void | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<void>;
+    cancel(): void;
+    download(dest: DownloadDest): Promise<void>;
+    stream(): AsyncGenerator<SegmentData>;
+    pipe(writable: Writable | WriteStream): Promise<void>;
+    info(): Promise<{
+        master?: HlsMasterPlaylist;
+        playlist?: HlsPlaylist;
+        selectedVariant?: HlsVariant;
+        isLive: boolean;
+        totalDuration?: number;
+    }>;
+    private resolveMediaPlaylist;
+    private fetchMediaPlaylist;
+    private downloadSegment;
+    private downloadMerged;
+    private downloadChunks;
+    private isLiveMode;
+    private getMaxDuration;
+    private emitProgress;
+    private sleep;
 }
-export declare function downloadHls(client: Client, manifestUrl: string, outputPath: string, options?: HlsOptions): Promise<void>;
-//# sourceMappingURL=hls.d.ts.map
+export declare function hls(client: Client, manifestUrl: string, options?: HlsOptions): HlsPromise;
+export type { HlsVariant as Variant, HlsSegment as Segment, HlsKeyInfo as KeyInfo, };