pup-recorder 0.1.7 → 0.1.9

package/build.ts

@@ -33,7 +33,7 @@ await Promise.all([
     entry: ["src/index.ts", "src/cli.ts"],
     format: "esm",
     outDir: "dist",
-    dts: true,
+    experimentalDts: true,
   }),
   build({
     ...common,

package/build_rust.ts

@@ -33,7 +33,7 @@ async function copyArtifact(platform: string, arch: string, dir: string) {
   const src = join(dir, libName);
   const destDir = join("rust");
   const dest = join(destDir, `${platform}-${arch}.bin`);
-  const dts = `declare const sth: Uint8Array;\nexport = sth;\n`;
+  const dts = `declare const sth: unknown;\nexport = sth;\n`;
   await mkdir(destDir, { recursive: true });
   await copyFile(src, dest);
   await writeFile(`${dest}.d.ts`, dts);

package/dist/_tsup-dts-rollup.d.ts

@@ -0,0 +1,371 @@
+import { BrowserWindow } from 'electron';
+import { ChildProcess } from 'child_process';
+import type { Debugger } from 'electron';
+import type { NativeImage } from 'electron';
+import { Size } from 'electron';
+import { SpawnOptions } from 'child_process';
+import z from 'zod';
+
+declare class AbortLink {
+    readonly query?: AbortQuery | undefined;
+    readonly interval: number;
+    private _callback?;
+    private _aborted?;
+    private _stopped;
+    private constructor();
+    static start(query?: AbortQuery, interval?: number): AbortLink;
+    get aborted(): boolean | undefined;
+    get stopped(): boolean;
+    onAbort(callback: AsyncTask): Promise<void>;
+    wait(...handles: ProcessHandle[]): Promise<unknown>;
+    stop(): void;
+    private tick;
+}
+export { AbortLink }
+export { AbortLink as AbortLink_alias_1 }
+
+declare type AbortQuery = () => Promise<boolean> | boolean;
+export { AbortQuery }
+export { AbortQuery as AbortQuery_alias_1 }
+
+export declare const app: string | undefined;
+
+declare type AsyncTask = () => Promise<void> | void;
+export { AsyncTask }
+export { AsyncTask as AsyncTask_alias_1 }
+
+export declare interface AudioCapture {
+    sampleRate?: number;
+    teardown(): Promise<void>;
+}
+
+declare interface AudioSpec {
+    pcmPath: string;
+    sampleRate: number;
+}
+export { AudioSpec }
+export { AudioSpec as AudioSpec_alias_1 }
+
+export declare const basedir: string;
+
+export declare interface BGRAFileOptions {
+    bgra: string;
+    outFile: string;
+    spec: VideoSpec;
+    audio?: AudioSpec;
+}
+
+export declare function buildRust(): Promise<void>;
+
+export declare function buildWrapperHTML(targetURL: string, size: Size): string;
+
+export declare const canIUseGPU: Promise<boolean>;
+
+export declare function checkHTML(source: string): void;
+
+export declare type CLICallback = (source: string, options: RenderOptions) => Promise<unknown>;
+
+declare interface Command {
+    command: string;
+    args: string[];
+}
+
+declare class ConcurrencyLimiter {
+    readonly maxConcurrency: number;
+    private _active;
+    private _queue;
+    private _ended;
+    constructor(maxConcurrency: number);
+    get active(): number;
+    get pending(): number;
+    get stats(): string;
+    schedule<T>(fn: () => Promise<T>): Promise<T>;
+    end(): Promise<void>;
+    private next;
+}
+export { ConcurrencyLimiter }
+export { ConcurrencyLimiter as ConcurrencyLimiter_alias_1 }
+
+export declare function createBGRA2MOVPipeline(x265: string, options: BGRAFileOptions): X265Pipeline;
+
+export declare function createBGRAFileCommand(options: BGRAFileOptions): Command;
+
+export declare function createCoverCommand(src: string, dst: string): Command;
+
+export declare function decodeTimestamp(bitmap: Buffer, size: Size): number | undefined;
+
+declare const DEFAULT_DURATION = 5;
+export { DEFAULT_DURATION }
+export { DEFAULT_DURATION as DEFAULT_DURATION_alias_1 }
+
+declare const DEFAULT_FPS = 30;
+export { DEFAULT_FPS }
+export { DEFAULT_FPS as DEFAULT_FPS_alias_1 }
+
+declare const DEFAULT_HEIGHT = 1080;
+export { DEFAULT_HEIGHT }
+export { DEFAULT_HEIGHT as DEFAULT_HEIGHT_alias_1 }
+
+declare const DEFAULT_OUT_DIR = "out";
+export { DEFAULT_OUT_DIR }
+export { DEFAULT_OUT_DIR as DEFAULT_OUT_DIR_alias_1 }
+
+declare const DEFAULT_WIDTH = 1920;
+export { DEFAULT_WIDTH }
+export { DEFAULT_WIDTH as DEFAULT_WIDTH_alias_1 }
+
+export declare function electronOpts(): Promise<string[]>;
+
+export declare function encodeBGRAFile(options: BGRAFileOptions): ProcessHandle;
+
+export declare function encodeBgraToMov(options: BGRAFileOptions): ProcessHandle;
+
+declare type EnvParser<T> = (value: unknown) => T;
+export { EnvParser }
+export { EnvParser as EnvParser_alias_1 }
+
+declare function exec(cmd: string, options?: SpawnOptions): ProcessHandle;
+export { exec }
+export { exec as exec_alias_1 }
+
+export declare interface FixedBufferWriter {
+    new (path: string, bufferSize: number, queueDepth?: number): FixedBufferWriter;
+    write(buffer: Buffer): void;
+    close(): Promise<void>;
+}
+
+export declare const FixedBufferWriter: FixedBufferWriter;
+
+export declare const FRAME_SYNC_MARKER_HEIGHT = 1;
+
+export declare const FRAME_SYNC_MARKER_WIDTH = 32;
+
+export declare function isEmpty(image: NativeImage): boolean;
+
+declare class Lazy<T> {
+    readonly makeValue: () => T;
+    constructor(makeValue: () => T);
+    get value(): T;
+    get initialized(): boolean;
+    private _initialized;
+    private _value;
+}
+export { Lazy }
+export { Lazy as Lazy_alias_1 }
+
+export declare function loadWindow(source: string, options: RenderOptions): Promise<BrowserWindow>;
+
+declare class Logger implements LoggerLike {
+    private _impl?;
+    get impl(): LoggerLike | undefined;
+    set impl(value: LoggerLike);
+    constructor();
+    debug(...messages: unknown[]): void;
+    info(...messages: unknown[]): void;
+    warn(...messages: unknown[]): void;
+    error(...messages: unknown[]): void;
+    fatal(...messages: unknown[]): void;
+    private dispatch;
+    attach(proc: ChildProcess, name: string): Promise<void>;
+}
+
+declare const logger: Logger;
+export { logger }
+export { logger as logger_alias_1 }
+
+declare interface LoggerLike {
+    debug?(this: void, ...messages: unknown[]): void;
+    info?(this: void, ...messages: unknown[]): void;
+    warn?(this: void, ...messages: unknown[]): void;
+    error?(this: void, ...messages: unknown[]): void;
+}
+export { LoggerLike }
+export { LoggerLike as LoggerLike_alias_1 }
+
+export declare function makeCLI(name: string, callback: CLICallback): Promise<void>;
+
+export declare function mountX265(): string;
+
+export declare interface NetworkOptions {
+    source: string;
+    window: BrowserWindow;
+    useInnerProxy?: boolean;
+}
+
+declare function noerr<Fn extends (...args: any[]) => any, D>(fn: Fn, defaultValue: D): (...args: Parameters<Fn>) => ReturnType<Fn> | D;
+export { noerr }
+export { noerr as noerr_alias_1 }
+
+declare function pargs(): string[];
+export { pargs }
+export { pargs as pargs_alias_1 }
+
+declare function parseNumber(value: unknown): number;
+export { parseNumber }
+export { parseNumber as parseNumber_alias_1 }
+
+declare function penv<T>(name: string, parser: EnvParser<T>, defaultValue: T): T;
+
+declare function penv<T>(name: string, parser: EnvParser<T>, defaultValue?: T): T | undefined;
+export { penv }
+export { penv as penv_alias_1 }
+
+declare function periodical(callback: (count: number) => Promise<void> | void, ms: number): () => void;
+export { periodical }
+export { periodical as periodical_alias_1 }
+
+declare interface ProcessHandle {
+    process: ChildProcess;
+    wait: Promise<void>;
+}
+export { ProcessHandle }
+export { ProcessHandle as ProcessHandle_alias_1 }
+
+export declare function proxiedUrl(url: string): string;
+
+declare function pup(source: string, options: PupOptions): Promise<PupResult>;
+export { pup }
+export { pup as pup_alias_1 }
+
+declare const PUP_ARGS_KEY = "--pup-priv-args";
+export { PUP_ARGS_KEY }
+export { PUP_ARGS_KEY as PUP_ARGS_KEY_alias_1 }
+
+declare const pupDisableGPU: boolean;
+export { pupDisableGPU }
+export { pupDisableGPU as pupDisableGPU_alias_1 }
+
+declare const pupFFmpegPath: string;
+export { pupFFmpegPath }
+export { pupFFmpegPath as pupFFmpegPath_alias_1 }
+
+declare const pupLogLevel: number;
+export { pupLogLevel }
+export { pupLogLevel as pupLogLevel_alias_1 }
+
+declare const pupNoCleanup: boolean;
+export { pupNoCleanup }
+export { pupNoCleanup as pupNoCleanup_alias_1 }
+
+declare interface PupOptions extends Partial<RenderOptions> {
+    cancelQuery?: AbortQuery;
+    onProgress?: PupProgressCallback;
+}
+export { PupOptions }
+export { PupOptions as PupOptions_alias_1 }
+
+declare type PupProgressCallback = (progress: number) => Promise<void> | void;
+export { PupProgressCallback }
+export { PupProgressCallback as PupProgressCallback_alias_1 }
+
+declare interface PupResult {
+    options: RenderOptions;
+    files: VideoFilesWithCover;
+}
+export { PupResult }
+export { PupResult as PupResult_alias_1 }
+
+declare const pupUseInnerProxy: boolean;
+export { pupUseInnerProxy }
+export { pupUseInnerProxy as pupUseInnerProxy_alias_1 }
+
+export declare function render(source: string, options: RenderOptions): Promise<void>;
+
+declare type RenderOptions = z.infer<typeof RenderSchema>;
+export { RenderOptions }
+export { RenderOptions as RenderOptions_alias_1 }
+
+declare interface RenderResult {
+    options: RenderOptions;
+    written: number;
+    bgra: string;
+    audio?: AudioSpec;
+}
+export { RenderResult }
+export { RenderResult as RenderResult_alias_1 }
+
+declare const RenderSchema: z.ZodObject<{
+    duration: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    fps: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    withAlphaChannel: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    withAudio: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    outDir: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    useInnerProxy: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export { RenderSchema }
+export { RenderSchema as RenderSchema_alias_1 }
+
+declare interface RetryOptions<Args extends any[], Ret> {
+    fn: (...args: Args) => Promise<Ret>;
+    maxAttempts?: number;
+    timeout?: number;
+}
+export { RetryOptions }
+export { RetryOptions as RetryOptions_alias_1 }
+
+export declare function runElectronApp(size: Size, args: unknown[]): Promise<ProcessHandle>;
+
+export declare function setInterceptor({ source, window, useInnerProxy, }: NetworkOptions): void;
+
+export declare function setupAudioCapture(pcmPath: string): Promise<AudioCapture>;
+
+declare function sleep(ms: number): Promise<void>;
+export { sleep }
+export { sleep as sleep_alias_1 }
+
+export declare function startSync(cdp: Debugger): Promise<any>;
+
+export declare function stopSync(cdp: Debugger): Promise<any>;
+
+export declare function unmountX265(path: string): void;
+
+export declare function unsetInterceptor(window: BrowserWindow): void;
+
+declare function useRetry<Args extends any[], Ret>({ fn, maxAttempts, timeout, }: RetryOptions<Args, Ret>): (...args: Args) => Promise<Ret>;
+export { useRetry }
+export { useRetry as useRetry_alias_1 }
+
+declare interface VideoFiles {
+    mp4?: string;
+    webm?: string;
+    mov?: string;
+}
+export { VideoFiles }
+export { VideoFiles as VideoFiles_alias_1 }
+
+declare interface VideoFilesWithCover extends VideoFiles {
+    cover: string;
+}
+export { VideoFilesWithCover }
+export { VideoFilesWithCover as VideoFilesWithCover_alias_1 }
+
+declare interface VideoSpec {
+    fps: number;
+    frames: number;
+    size: Size;
+}
+export { VideoSpec }
+export { VideoSpec as VideoSpec_alias_1 }
+
+export declare class WaitableEvent {
+    private _promise?;
+    private _resolve?;
+    private _timeoutToken?;
+    wait(options?: WaitOptions): Promise<void>;
+    signal(): void;
+}
+
+export declare interface WaitOptions {
+    timeout: number;
+    onTimeout?: () => void;
+}
+
+declare interface X265Pipeline {
+    raw: Command;
+    x265: Command;
+    mux: Command;
+}
+
+export { }