@remotion/renderer 4.0.0-defer.6 → 4.0.0-esm.17

package/package.json

@@ -1,17 +1,19 @@
 {
 	"name": "@remotion/renderer",
-	"version": "4.0.0-defer.6+6f645f9d4",
+	"version": "4.0.0-esm.17+da08690d2",
 	"description": "Renderer for Remotion",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"sideEffects": false,
 	"scripts": {
 		"lint": "eslint src --ext ts,tsx",
-		"test": "jest --runInBand",
+		"test": "vitest --run",
 		"watch": "tsc -w",
-		"build": "tsc -d"
+		"build": "node build.mjs && tsc -d",
+		"build-all": "node build.mjs --all",
+		"prepublishOnly": "node build.mjs --all"
 	},
-	"author": "",
+	"author": "Jonny Burger <jonny@remotion.dev>",
 	"license": "SEE LICENSE IN LICENSE.md",
 	"repository": {
 		"url": "https://github.com/remotion-dev/remotion"
@@ -21,43 +23,49 @@
 	},
 	"dependencies": {
 		"execa": "5.1.1",
-		"mime-types": "2.1.35",
-		"puppeteer-core": "13.5.1",
-		"remotion": "4.0.0-defer.6+6f645f9d4",
-		"source-map": "^0.8.0-beta.0"
+		"extract-zip": "2.0.1",
+		"remotion": "4.0.0-esm.17+da08690d2",
+		"source-map": "^0.8.0-beta.0",
+		"ws": "8.7.0"
 	},
 	"peerDependencies": {
 		"react": ">=16.8.0",
 		"react-dom": ">=16.8.0"
 	},
 	"devDependencies": {
-		"@jonny/eslint-config": "3.0.259",
-		"@testing-library/dom": "^8.7.2",
-		"@testing-library/react": "13.1.1",
-		"@types/jest": "^27.4.0",
-		"@types/mime-types": "2.1.1",
+		"@jonny/eslint-config": "3.0.266",
+		"@testing-library/dom": "^8.16.0",
+		"@testing-library/react": "13.3.0",
 		"@types/node": "^16.7.5",
-		"@types/react": "18.0.1",
-		"@types/react-dom": "18.0.0",
-		"eslint": "8.13.0",
-		"jest": "^27.2.4",
-		"prettier": "^2.0.5",
+		"@types/progress": "2.0.5",
+		"@types/react": "18.0.26",
+		"@types/react-dom": "18.0.10",
+		"eslint": "8.25.0",
+		"prettier": "^2.7.1",
 		"prettier-plugin-organize-imports": "^2.3.4",
 		"react": "18.0.0",
 		"react-dom": "18.0.0",
-		"ts-jest": "^27.0.5",
-		"typescript": "^4.7.0"
+		"typescript": "^4.7.0",
+		"vitest": "0.24.3"
+	},
+	"optionalDependencies": {
+		"@remotion/compositor-darwin-arm64": "4.0.0-esm.17+da08690d2",
+		"@remotion/compositor-darwin-x64": "4.0.0-esm.17+da08690d2",
+		"@remotion/compositor-linux-arm64-gnu": "4.0.0-esm.17+da08690d2",
+		"@remotion/compositor-linux-arm64-musl": "4.0.0-esm.17+da08690d2",
+		"@remotion/compositor-linux-x64-gnu": "4.0.0-esm.17+da08690d2",
+		"@remotion/compositor-linux-x64-musl": "4.0.0-esm.17+da08690d2",
+		"@remotion/compositor-win32-x64-msvc": "4.0.0-esm.17+da08690d2"
 	},
 	"keywords": [
 		"remotion",
 		"ffmpeg",
 		"video",
 		"react",
-		"puppeteer",
 		"player"
 	],
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "6f645f9d4698c18c950a8550877adf9735dc4b31"
+	"gitHead": "da08690d241e1f5d6dde8a8d89f3379a54ec7681"
 }

package/types/ws/index.d.ts

@@ -0,0 +1,509 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable lines-between-class-members */
+/* eslint-disable no-redeclare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable @typescript-eslint/no-shadow */
+/* eslint-disable no-dupe-class-members */
+/// <reference types="node" />
+
+import {EventEmitter} from 'events';
+import type {
+	Agent,
+	ClientRequest,
+	ClientRequestArgs,
+	IncomingMessage,
+	OutgoingHttpHeaders,
+	Server as HTTPServer,
+} from 'http';
+import type {Server as HTTPSServer} from 'https';
+import type {Duplex, DuplexOptions} from 'stream';
+import type {SecureContextOptions} from 'tls';
+import type {URL} from 'url';
+import type {ZlibOptions} from 'zlib';
+declare class WebSocket extends EventEmitter {
+	/** The connection is not yet open. */
+	static readonly CONNECTING: 0;
+	/** The connection is open and ready to communicate. */
+	static readonly OPEN: 1;
+	/** The connection is in the process of closing. */
+	static readonly CLOSING: 2;
+	/** The connection is closed. */
+	static readonly CLOSED: 3;
+	binaryType: 'nodebuffer' | 'arraybuffer' | 'fragments';
+	readonly bufferedAmount: number;
+	readonly extensions: string;
+	/** Indicates whether the websocket is paused */
+	readonly isPaused: boolean;
+	readonly protocol: string;
+	/** The current state of the connection */
+	readonly readyState:
+		| typeof WebSocket.CONNECTING
+		| typeof WebSocket.OPEN
+		| typeof WebSocket.CLOSING
+		| typeof WebSocket.CLOSED;
+	readonly url: string;
+	/** The connection is not yet open. */
+	readonly CONNECTING: 0;
+	/** The connection is open and ready to communicate. */
+	readonly OPEN: 1;
+	/** The connection is in the process of closing. */
+	readonly CLOSING: 2;
+	/** The connection is closed. */
+	readonly CLOSED: 3;
+	onopen: ((event: WebSocket.Event) => void) | null;
+	onerror: ((event: WebSocket.ErrorEvent) => void) | null;
+	onclose: ((event: WebSocket.CloseEvent) => void) | null;
+	onmessage: ((event: WebSocket.MessageEvent) => void) | null;
+	constructor(address: null);
+	constructor(
+		address: string | URL,
+		options?: WebSocket.ClientOptions | ClientRequestArgs
+	);
+	constructor(
+		address: string | URL,
+		protocols?: string | string[],
+		options?: WebSocket.ClientOptions | ClientRequestArgs
+	);
+	close(code?: number, data?: string | Buffer): void;
+	ping(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
+	pong(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
+	send(data: any, cb?: (err?: Error) => void): void;
+	send(
+		data: any,
+		options: {
+			mask?: boolean | undefined;
+			binary?: boolean | undefined;
+			compress?: boolean | undefined;
+			fin?: boolean | undefined;
+		},
+		cb?: (err?: Error) => void
+	): void;
+	terminate(): void;
+	/**
+	 * Pause the websocket causing it to stop emitting events. Some events can still be
+	 * emitted after this is called, until all buffered data is consumed. This method
+	 * is a noop if the ready state is `CONNECTING` or `CLOSED`.
+	 */
+	pause(): void;
+	/**
+	 * Make a paused socket resume emitting events. This method is a noop if the ready
+	 * state is `CONNECTING` or `CLOSED`.
+	 */
+	resume(): void;
+	addEventListener(
+		method: 'message',
+		cb: (event: WebSocket.MessageEvent) => void,
+		options?: WebSocket.EventListenerOptions
+	): void;
+	addEventListener(
+		method: 'close',
+		cb: (event: WebSocket.CloseEvent) => void,
+		options?: WebSocket.EventListenerOptions
+	): void;
+	addEventListener(
+		method: 'error',
+		cb: (event: WebSocket.ErrorEvent) => void,
+		options?: WebSocket.EventListenerOptions
+	): void;
+	addEventListener(
+		method: 'open',
+		cb: (event: WebSocket.Event) => void,
+		options?: WebSocket.EventListenerOptions
+	): void;
+	removeEventListener(
+		method: 'message',
+		cb: (event: WebSocket.MessageEvent) => void
+	): void;
+	removeEventListener(
+		method: 'close',
+		cb: (event: WebSocket.CloseEvent) => void
+	): void;
+	removeEventListener(
+		method: 'error',
+		cb: (event: WebSocket.ErrorEvent) => void
+	): void;
+	removeEventListener(
+		method: 'open',
+		cb: (event: WebSocket.Event) => void
+	): void;
+	on(
+		event: 'close',
+		listener: (this: WebSocket, code: number, reason: Buffer) => void
+	): this;
+	on(event: 'error', listener: (this: WebSocket, err: Error) => void): this;
+	on(
+		event: 'upgrade',
+		listener: (this: WebSocket, request: IncomingMessage) => void
+	): this;
+	on(
+		event: 'message',
+		listener: (
+			this: WebSocket,
+			data: WebSocket.RawData,
+			isBinary: boolean
+		) => void
+	): this;
+	on(event: 'open', listener: (this: WebSocket) => void): this;
+	on(
+		event: 'ping' | 'pong',
+		listener: (this: WebSocket, data: Buffer) => void
+	): this;
+	on(
+		event: 'unexpected-response',
+		listener: (
+			this: WebSocket,
+			request: ClientRequest,
+			response: IncomingMessage
+		) => void
+	): this;
+	on(
+		event: string | symbol,
+		listener: (this: WebSocket, ...args: any[]) => void
+	): this;
+	once(
+		event: 'close',
+		listener: (this: WebSocket, code: number, reason: Buffer) => void
+	): this;
+	once(event: 'error', listener: (this: WebSocket, err: Error) => void): this;
+	once(
+		event: 'upgrade',
+		listener: (this: WebSocket, request: IncomingMessage) => void
+	): this;
+	once(
+		event: 'message',
+		listener: (
+			this: WebSocket,
+			data: WebSocket.RawData,
+			isBinary: boolean
+		) => void
+	): this;
+	once(event: 'open', listener: (this: WebSocket) => void): this;
+	once(
+		event: 'ping' | 'pong',
+		listener: (this: WebSocket, data: Buffer) => void
+	): this;
+	once(
+		event: 'unexpected-response',
+		listener: (
+			this: WebSocket,
+			request: ClientRequest,
+			response: IncomingMessage
+		) => void
+	): this;
+	once(
+		event: string | symbol,
+		listener: (this: WebSocket, ...args: any[]) => void
+	): this;
+	off(
+		event: 'close',
+		listener: (this: WebSocket, code: number, reason: Buffer) => void
+	): this;
+	off(event: 'error', listener: (this: WebSocket, err: Error) => void): this;
+	off(
+		event: 'upgrade',
+		listener: (this: WebSocket, request: IncomingMessage) => void
+	): this;
+	off(
+		event: 'message',
+		listener: (
+			this: WebSocket,
+			data: WebSocket.RawData,
+			isBinary: boolean
+		) => void
+	): this;
+	off(event: 'open', listener: (this: WebSocket) => void): this;
+	off(
+		event: 'ping' | 'pong',
+		listener: (this: WebSocket, data: Buffer) => void
+	): this;
+	off(
+		event: 'unexpected-response',
+		listener: (
+			this: WebSocket,
+			request: ClientRequest,
+			response: IncomingMessage
+		) => void
+	): this;
+	off(
+		event: string | symbol,
+		listener: (this: WebSocket, ...args: any[]) => void
+	): this;
+	addListener(
+		event: 'close',
+		listener: (code: number, reason: Buffer) => void
+	): this;
+	addListener(event: 'error', listener: (err: Error) => void): this;
+	addListener(
+		event: 'upgrade',
+		listener: (request: IncomingMessage) => void
+	): this;
+	addListener(
+		event: 'message',
+		listener: (data: WebSocket.RawData, isBinary: boolean) => void
+	): this;
+	addListener(event: 'open', listener: () => void): this;
+	addListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this;
+	addListener(
+		event: 'unexpected-response',
+		listener: (request: ClientRequest, response: IncomingMessage) => void
+	): this;
+	addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+	removeListener(
+		event: 'close',
+		listener: (code: number, reason: Buffer) => void
+	): this;
+	removeListener(event: 'error', listener: (err: Error) => void): this;
+	removeListener(
+		event: 'upgrade',
+		listener: (request: IncomingMessage) => void
+	): this;
+	removeListener(
+		event: 'message',
+		listener: (data: WebSocket.RawData, isBinary: boolean) => void
+	): this;
+	removeListener(event: 'open', listener: () => void): this;
+	removeListener(
+		event: 'ping' | 'pong',
+		listener: (data: Buffer) => void
+	): this;
+	removeListener(
+		event: 'unexpected-response',
+		listener: (request: ClientRequest, response: IncomingMessage) => void
+	): this;
+	removeListener(
+		event: string | symbol,
+		listener: (...args: any[]) => void
+	): this;
+}
+declare const WebSocketAlias: typeof WebSocket;
+declare type WebSocketAlias = WebSocket;
+declare namespace WebSocket {
+	/**
+	 * Data represents the raw message payload received over the WebSocket.
+	 */
+	type RawData = Buffer | ArrayBuffer | Buffer[];
+	/**
+	 * Data represents the message payload received over the WebSocket.
+	 */
+	type Data = string | Buffer | ArrayBuffer | Buffer[];
+	/**
+	 * CertMeta represents the accepted types for certificate & key data.
+	 */
+	type CertMeta = string | string[] | Buffer | Buffer[];
+	/**
+	 * VerifyClientCallbackSync is a synchronous callback used to inspect the
+	 * incoming message. The return value (boolean) of the function determines
+	 * whether or not to accept the handshake.
+	 */
+	type VerifyClientCallbackSync = (info: {
+		origin: string;
+		secure: boolean;
+		req: IncomingMessage;
+	}) => boolean;
+	/**
+	 * VerifyClientCallbackAsync is an asynchronous callback used to inspect the
+	 * incoming message. The return value (boolean) of the function determines
+	 * whether or not to accept the handshake.
+	 */
+	type VerifyClientCallbackAsync = (
+		info: {
+			origin: string;
+			secure: boolean;
+			req: IncomingMessage;
+		},
+		callback: (
+			res: boolean,
+			code?: number,
+			message?: string,
+			headers?: OutgoingHttpHeaders
+		) => void
+	) => void;
+	interface ClientOptions extends SecureContextOptions {
+		protocol?: string | undefined;
+		followRedirects?: boolean | undefined;
+		generateMask?(mask: Buffer): void;
+		handshakeTimeout?: number | undefined;
+		maxRedirects?: number | undefined;
+		perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
+		localAddress?: string | undefined;
+		protocolVersion?: number | undefined;
+		headers?:
+			| {
+					[key: string]: string;
+			  }
+			| undefined;
+		origin?: string | undefined;
+		agent?: Agent | undefined;
+		host?: string | undefined;
+		family?: number | undefined;
+		checkServerIdentity?(servername: string, cert: CertMeta): boolean;
+		rejectUnauthorized?: boolean | undefined;
+		maxPayload?: number | undefined;
+		skipUTF8Validation?: boolean | undefined;
+	}
+	interface PerMessageDeflateOptions {
+		serverNoContextTakeover?: boolean | undefined;
+		clientNoContextTakeover?: boolean | undefined;
+		serverMaxWindowBits?: number | undefined;
+		clientMaxWindowBits?: number | undefined;
+		zlibDeflateOptions?:
+			| {
+					flush?: number | undefined;
+					finishFlush?: number | undefined;
+					chunkSize?: number | undefined;
+					windowBits?: number | undefined;
+					level?: number | undefined;
+					memLevel?: number | undefined;
+					strategy?: number | undefined;
+					dictionary?: Buffer | Buffer[] | DataView | undefined;
+					info?: boolean | undefined;
+			  }
+			| undefined;
+		zlibInflateOptions?: ZlibOptions | undefined;
+		threshold?: number | undefined;
+		concurrencyLimit?: number | undefined;
+	}
+	interface Event {
+		type: string;
+		target: WebSocket;
+	}
+	interface ErrorEvent {
+		error: any;
+		message: string;
+		type: string;
+		target: WebSocket;
+	}
+	interface CloseEvent {
+		wasClean: boolean;
+		code: number;
+		reason: string;
+		type: string;
+		target: WebSocket;
+	}
+	interface MessageEvent {
+		data: Data;
+		type: string;
+		target: WebSocket;
+	}
+	interface EventListenerOptions {
+		once?: boolean | undefined;
+	}
+	interface ServerOptions {
+		host?: string | undefined;
+		port?: number | undefined;
+		backlog?: number | undefined;
+		server?: HTTPServer | HTTPSServer | undefined;
+		verifyClient?:
+			| VerifyClientCallbackAsync
+			| VerifyClientCallbackSync
+			| undefined;
+		handleProtocols?: (
+			protocols: Set<string>,
+			request: IncomingMessage
+		) => string | false;
+		path?: string | undefined;
+		noServer?: boolean | undefined;
+		clientTracking?: boolean | undefined;
+		perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
+		maxPayload?: number | undefined;
+		skipUTF8Validation?: boolean | undefined;
+		WebSocket?: typeof WebSocket.WebSocket | undefined;
+	}
+	interface AddressInfo {
+		address: string;
+		family: string;
+		port: number;
+	}
+	class Server<T extends WebSocket = WebSocket> extends EventEmitter {
+		options: ServerOptions;
+		path: string;
+		clients: Set<T>;
+		constructor(options?: ServerOptions, callback?: () => void);
+		address(): AddressInfo | string;
+		close(cb?: (err?: Error) => void): void;
+		handleUpgrade(
+			request: IncomingMessage,
+			socket: Duplex,
+			upgradeHead: Buffer,
+			callback: (client: T, request: IncomingMessage) => void
+		): void;
+		shouldHandle(request: IncomingMessage): boolean | Promise<boolean>;
+		on(
+			event: 'connection',
+			cb: (this: Server<T>, socket: T, request: IncomingMessage) => void
+		): this;
+		on(event: 'error', cb: (this: Server<T>, error: Error) => void): this;
+		on(
+			event: 'headers',
+			cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void
+		): this;
+		on(event: 'close' | 'listening', cb: (this: Server<T>) => void): this;
+		on(
+			event: string | symbol,
+			listener: (this: Server<T>, ...args: any[]) => void
+		): this;
+		once(
+			event: 'connection',
+			cb: (this: Server<T>, socket: T, request: IncomingMessage) => void
+		): this;
+		once(event: 'error', cb: (this: Server<T>, error: Error) => void): this;
+		once(
+			event: 'headers',
+			cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void
+		): this;
+		once(event: 'close' | 'listening', cb: (this: Server<T>) => void): this;
+		once(
+			event: string | symbol,
+			listener: (this: Server<T>, ...args: any[]) => void
+		): this;
+		off(
+			event: 'connection',
+			cb: (this: Server<T>, socket: T, request: IncomingMessage) => void
+		): this;
+		off(event: 'error', cb: (this: Server<T>, error: Error) => void): this;
+		off(
+			event: 'headers',
+			cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void
+		): this;
+		off(event: 'close' | 'listening', cb: (this: Server<T>) => void): this;
+		off(
+			event: string | symbol,
+			listener: (this: Server<T>, ...args: any[]) => void
+		): this;
+		addListener(
+			event: 'connection',
+			cb: (client: T, request: IncomingMessage) => void
+		): this;
+		addListener(event: 'error', cb: (err: Error) => void): this;
+		addListener(
+			event: 'headers',
+			cb: (headers: string[], request: IncomingMessage) => void
+		): this;
+		addListener(event: 'close' | 'listening', cb: () => void): this;
+		addListener(
+			event: string | symbol,
+			listener: (...args: any[]) => void
+		): this;
+		removeListener(event: 'connection', cb: (client: T) => void): this;
+		removeListener(event: 'error', cb: (err: Error) => void): this;
+		removeListener(
+			event: 'headers',
+			cb: (headers: string[], request: IncomingMessage) => void
+		): this;
+		removeListener(event: 'close' | 'listening', cb: () => void): this;
+		removeListener(
+			event: string | symbol,
+			listener: (...args: any[]) => void
+		): this;
+	}
+	const WebSocketServer: typeof Server;
+	interface WebSocketServer extends Server {}
+	const WebSocket: typeof WebSocketAlias;
+	interface WebSocket extends WebSocketAlias {}
+	function createWebSocketStream(
+		websocket: WebSocket,
+		options?: DuplexOptions
+	): Duplex;
+}
+
+export = WebSocket;

package/.prettierrc.js

@@ -1,14 +0,0 @@
-module.exports = {
-	singleQuote: true,
-	bracketSpacing: false,
-	useTabs: true,
-	overrides: [
-		{
-			files: ['*.yml'],
-			options: {
-				singleQuote: false,
-			},
-		},
-	],
-	plugins: [require.resolve('prettier-plugin-organize-imports')],
-};

package/dist/abort.d.ts

@@ -1,7 +0,0 @@
-declare type Callback = () => void;
-export declare type CancelSignal = (callback: Callback) => void;
-export declare const getCancelSignal: () => {
-    cancelSignal: CancelSignal;
-    cancel: () => void;
-};
-export {};

package/dist/abort.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCancelSignal = void 0;
-const getCancelSignal = () => {
-    const callbacks = [];
-    let cancelled = false;
-    return {
-        cancelSignal: (callback) => callbacks.push(callback),
-        cancel: () => {
-            if (cancelled) {
-                return;
-            }
-            callbacks.forEach((cb) => {
-                cb();
-            });
-            cancelled = true;
-        },
-    };
-};
-exports.getCancelSignal = getCancelSignal;

package/dist/assets/cleanup-assets.d.ts

@@ -1,2 +0,0 @@
-export declare type RenderCleanupFn = () => Promise<void>;
-export declare type AddRenderCleanupFunction = (cleanup: RenderCleanupFn) => void;

package/dist/cancel.d.ts

@@ -1,7 +0,0 @@
-declare type Callback = () => void;
-export declare type CancelSignal = (callback: Callback) => void;
-export declare const makeCancelSignal: () => {
-    cancelSignal: CancelSignal;
-    cancel: () => void;
-};
-export {};

package/dist/cancel.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeCancelSignal = void 0;
-const makeCancelSignal = () => {
-    const callbacks = [];
-    let cancelled = false;
-    return {
-        cancelSignal: (callback) => {
-            callbacks.push(callback);
-            if (cancelled) {
-                callback();
-            }
-        },
-        cancel: () => {
-            if (cancelled) {
-                return;
-            }
-            callbacks.forEach((cb) => {
-                cb();
-            });
-            cancelled = true;
-        },
-    };
-};
-exports.makeCancelSignal = makeCancelSignal;

package/dist/ensure-faststart.d.ts

@@ -1 +0,0 @@
-export declare const ensureFastStart: () => void;