@remotion/cli 4.0.0-webhook.27 → 4.1.0-alpha1

package/dist/preview-server/get-package-manager.d.ts

@@ -1,10 +1,10 @@
-export declare type PackageManager = 'npm' | 'yarn' | 'pnpm';
-declare type LockfilePath = {
+export type PackageManager = 'npm' | 'yarn' | 'pnpm';
+type LockfilePath = {
     manager: PackageManager;
     path: string;
     installCommand: string;
     startCommand: string;
 };
 export declare const lockFilePaths: LockfilePath[];
-export declare const getPackageManager: (remotionRoot: string) => LockfilePath | 'unknown';
+export declare const getPackageManager: (remotionRoot: string, packageManager: string | undefined) => LockfilePath | 'unknown';
 export {};

package/dist/preview-server/get-package-manager.js

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPackageManager = exports.lockFilePaths = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 exports.lockFilePaths = [
     {
         path: 'package-lock.json',
@@ -26,8 +26,17 @@ exports.lockFilePaths = [
         startCommand: 'pnpm start',
     },
 ];
-const getPackageManager = (remotionRoot) => {
-    const existingPkgManagers = exports.lockFilePaths.filter((p) => fs_1.default.existsSync(path_1.default.join(remotionRoot, p.path)));
+const getPackageManager = (remotionRoot, packageManager) => {
+    if (packageManager) {
+        const manager = exports.lockFilePaths.find((p) => p.manager === packageManager);
+        if (!manager) {
+            throw new Error(`The package manager ${packageManager} is not supported. Supported package managers are ${exports.lockFilePaths
+                .map((p) => p.manager)
+                .join(', ')}`);
+        }
+        return manager;
+    }
+    const existingPkgManagers = exports.lockFilePaths.filter((p) => node_fs_1.default.existsSync(node_path_1.default.join(remotionRoot, p.path)));
     if (existingPkgManagers.length === 0) {
         return 'unknown';
     }

package/dist/preview-server/handler.d.ts

@@ -0,0 +1,9 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { ApiHandler } from './api-types';
+export declare const handleRequest: <Req, Res>({ remotionRoot, request, response, entryPoint, handler, }: {
+    remotionRoot: string;
+    request: IncomingMessage;
+    response: ServerResponse;
+    entryPoint: string;
+    handler: ApiHandler<Req, Res>;
+}) => Promise<void>;

package/dist/preview-server/handler.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRequest = void 0;
+const parse_body_1 = require("./parse-body");
+const handleRequest = async ({ remotionRoot, request, response, entryPoint, handler, }) => {
+    if (request.method === 'OPTIONS') {
+        response.statusCode = 200;
+        response.end();
+        return;
+    }
+    response.setHeader('content-type', 'application/json');
+    response.writeHead(200);
+    try {
+        const body = (await (0, parse_body_1.parseRequestBody)(request));
+        const outputData = await handler({
+            entryPoint,
+            remotionRoot,
+            request,
+            response,
+            input: body,
+        });
+        response.end(JSON.stringify({
+            success: true,
+            data: outputData,
+        }));
+    }
+    catch (err) {
+        response.end(JSON.stringify({
+            success: false,
+            error: err.message,
+        }));
+    }
+};
+exports.handleRequest = handleRequest;

package/dist/preview-server/hot-middleware/client.d.ts

@@ -10,7 +10,7 @@ declare global {
         __webpack_hot_middleware_reporter__: Reporter;
     }
 }
-declare type Reporter = ReturnType<typeof createReporter>;
+type Reporter = ReturnType<typeof createReporter>;
 declare function createReporter(): {
     cleanProblemsCache(): void;
     problems(type: 'errors' | 'warnings', obj: HotMiddlewareMessage): boolean;

package/dist/preview-server/hot-middleware/client.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * https://github.com/webpack-contrib/webpack-hot-middleware#readme
  * and rewritten in TypeScript. This file is MIT licensed
  */
+const ansi_split_1 = require("../../ansi/ansi-split");
 const process_update_1 = require("./process-update");
-const strip_ansi_1 = require("./strip-ansi");
 const types_1 = require("./types");
 if (typeof window === 'undefined') {
     // do nothing
@@ -107,7 +107,7 @@ function createReporter() {
         }
         const newProblems = obj[type]
             .map((msg) => {
-            return (0, strip_ansi_1.stripAnsi)(msg);
+            return (0, ansi_split_1.stripAnsi)(msg);
         })
             .join('\n');
         if (previousProblems === newProblems) {

package/dist/preview-server/hot-middleware/index.d.ts

@@ -4,5 +4,99 @@
  * and rewritten in TypeScript. This file is MIT licensed
  */
 import type { webpack } from '@remotion/bundler';
-import type { IncomingMessage, ServerResponse } from 'http';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+declare global {
+    const __webpack_hash__: unknown;
+    interface HotNotifierInfo {
+        type: 'self-declined' | 'declined' | 'unaccepted' | 'accepted' | 'disposed' | 'accept-errored' | 'self-accept-errored' | 'self-accept-error-handler-errored';
+        /**
+         * The module in question.
+         */
+        moduleId: number;
+        /**
+         * For errors: the module id owning the accept handler.
+         */
+        dependencyId?: number | undefined;
+        /**
+         * For declined/accepted/unaccepted: the chain from where the update was propagated.
+         */
+        chain?: number[] | undefined;
+        /**
+         * For declined: the module id of the declining parent
+         */
+        parentId?: number | undefined;
+        /**
+         * For accepted: the modules that are outdated and will be disposed
+         */
+        outdatedModules?: number[] | undefined;
+        /**
+         * For accepted: The location of accept handlers that will handle the update
+         */
+        outdatedDependencies?: {
+            [dependencyId: number]: number[];
+        } | undefined;
+        /**
+         * For errors: the thrown error
+         */
+        error?: Error | undefined;
+        /**
+         * For self-accept-error-handler-errored: the error thrown by the module
+         * before the error handler tried to handle it.
+         */
+        originalError?: Error | undefined;
+    }
+    interface AcceptOptions {
+        /**
+         * If true the update process continues even if some modules are not accepted (and would bubble to the entry point).
+         */
+        ignoreUnaccepted?: boolean | undefined;
+        /**
+         * Ignore changes made to declined modules.
+         */
+        ignoreDeclined?: boolean | undefined;
+        /**
+         *  Ignore errors throw in accept handlers, error handlers and while reevaluating module.
+         */
+        ignoreErrored?: boolean | undefined;
+        /**
+         * Notifier for declined modules.
+         */
+        onDeclined?: ((info: HotNotifierInfo) => void) | undefined;
+        /**
+         * Notifier for unaccepted modules.
+         */
+        onUnaccepted?: ((info: HotNotifierInfo) => void) | undefined;
+        /**
+         * Notifier for accepted modules.
+         */
+        onAccepted?: ((info: HotNotifierInfo) => void) | undefined;
+        /**
+         * Notifier for disposed modules.
+         */
+        onDisposed?: ((info: HotNotifierInfo) => void) | undefined;
+        /**
+         * Notifier for errors.
+         */
+        onErrored?: ((info: HotNotifierInfo) => void) | undefined;
+        /**
+         * Indicates that apply() is automatically called by check function
+         */
+        autoApply?: boolean | undefined;
+    }
+    const __webpack_module__: {
+        id: string;
+        exports: unknown;
+        hot: {
+            accept: () => void;
+            dispose: (onDispose: (data: Record<string, unknown>) => void) => void;
+            invalidate: () => void;
+            data?: Record<string, unknown>;
+            addStatusHandler(callback: (status: string) => void): void;
+            status(): string;
+            apply(options?: AcceptOptions): Promise<ModuleId[]>;
+            check(autoApply?: boolean): Promise<null | ModuleId[]>;
+        };
+    };
+    type ModuleId = string | number;
+}
 export declare const webpackHotMiddleware: (compiler: webpack.Compiler) => (req: IncomingMessage, res: ServerResponse, next: () => void) => void;

package/dist/preview-server/hot-middleware/index.js

@@ -6,12 +6,12 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.webpackHotMiddleware = void 0;
-const url_1 = require("url");
+const node_url_1 = require("node:url");
 const log_1 = require("../../log");
 const types_1 = require("./types");
 const pathMatch = function (url, path) {
     try {
-        return (0, url_1.parse)(url).pathname === path;
+        return (0, node_url_1.parse)(url).pathname === path;
     }
     catch (e) {
         return false;
@@ -24,7 +24,7 @@ const webpackHotMiddleware = (compiler) => {
     compiler.hooks.done.tap('remotion', onDone);
     function onInvalid() {
         latestStats = null;
-        log_1.Log.info('webpack building...');
+        log_1.Log.info('Building...');
         eventStream === null || eventStream === void 0 ? void 0 : eventStream.publish({
             action: 'building',
         });
@@ -114,7 +114,6 @@ function publishStats(action, statsResult, eventStream) {
         if (bundles.length === 1 && !name && statsResult.compilation) {
             name = statsResult.compilation.name || '';
         }
-        log_1.Log.info(`webpack built in ${_stats.time}ms`);
         eventStream === null || eventStream === void 0 ? void 0 : eventStream.publish({
             name,
             action,

package/dist/preview-server/hot-middleware/process-update.js

@@ -7,8 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processUpdate = void 0;
-/* global  __webpack_hash__ */
-if (!module.hot) {
+if (!__webpack_module__.hot) {
     throw new Error('[Fast refresh] Hot Module Replacement is disabled.');
 }
 const hmrDocsUrl = 'https://webpack.js.org/concepts/hot-module-replacement/'; // eslint-disable-line max-len
@@ -44,7 +43,7 @@ function upToDate(hash) {
 const processUpdate = function (hash, moduleMap, options) {
     var _a;
     const { reload } = options;
-    if (!upToDate(hash) && ((_a = module.hot) === null || _a === void 0 ? void 0 : _a.status()) === 'idle') {
+    if (!upToDate(hash) && ((_a = __webpack_module__.hot) === null || _a === void 0 ? void 0 : _a.status()) === 'idle') {
         check();
     }
     async function check() {
@@ -69,7 +68,7 @@ const processUpdate = function (hash, moduleMap, options) {
                 }
                 logUpdates(updatedModules, renewedModules);
             };
-            const applyResult = (_a = module.hot) === null || _a === void 0 ? void 0 : _a.apply(applyOptions, applyCallback);
+            const applyResult = (_a = __webpack_module__.hot) === null || _a === void 0 ? void 0 : _a.apply(applyOptions);
             if (applyResult === null || applyResult === void 0 ? void 0 : applyResult.then) {
                 // HotModuleReplacement.runtime.js refers to the result as `outdatedModules`
                 applyResult
@@ -80,7 +79,7 @@ const processUpdate = function (hash, moduleMap, options) {
             }
         };
         try {
-            const result = await ((_a = module.hot) === null || _a === void 0 ? void 0 : _a.check(false, cb));
+            const result = await ((_a = __webpack_module__.hot) === null || _a === void 0 ? void 0 : _a.check(false));
             cb(null, result);
         }
         catch (err) {
@@ -119,7 +118,7 @@ const processUpdate = function (hash, moduleMap, options) {
     }
     function handleError(err) {
         var _a, _b;
-        if (((_b = (_a = module.hot) === null || _a === void 0 ? void 0 : _a.status()) !== null && _b !== void 0 ? _b : 'nope') in failureStatuses) {
+        if (((_b = (_a = __webpack_module__.hot) === null || _a === void 0 ? void 0 : _a.status()) !== null && _b !== void 0 ? _b : 'nope') in failureStatuses) {
             if (options.warn) {
                 console.warn('[Fast refresh] Cannot check for update (Full reload needed)');
                 console.warn('[Fast refresh] ' + (err.stack || err.message));

package/dist/preview-server/hot-middleware/types.d.ts

@@ -1,5 +1,5 @@
 import type { webpack } from '@remotion/bundler';
-export declare type HotMiddlewareMessage = {
+export type HotMiddlewareMessage = {
     action: 'building';
     name?: string;
 } | {
@@ -20,8 +20,8 @@ export declare const hotMiddlewareOptions: {
     warn: boolean;
     heartbeat: number;
 };
-export declare type HotMiddlewareOptions = typeof hotMiddlewareOptions;
-export declare type WebpackStats = ReturnType<webpack.Stats['toJson']>;
-export declare type ModuleMap = {
+export type HotMiddlewareOptions = typeof hotMiddlewareOptions;
+export type WebpackStats = ReturnType<webpack.Stats['toJson']>;
+export type ModuleMap = {
     [key: string]: string;
 };

package/dist/preview-server/live-events.d.ts

@@ -1,8 +1,10 @@
 /// <reference types="node" />
-import type { IncomingMessage, ServerResponse } from 'http';
+import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { EventSourceEvent } from '../event-source-events';
-export declare type LiveEventsServer = {
+export type LiveEventsServer = {
     sendEventToClient: (event: EventSourceEvent) => void;
     router: (request: IncomingMessage, response: ServerResponse) => void;
 };
 export declare const makeLiveEventsRouter: () => LiveEventsServer;
+export declare const waitForLiveEventsListener: () => Promise<LiveEventsServer>;
+export declare const setLiveEventsListener: (listener: LiveEventsServer) => void;

package/dist/preview-server/live-events.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeLiveEventsRouter = void 0;
+exports.setLiveEventsListener = exports.waitForLiveEventsListener = exports.makeLiveEventsRouter = void 0;
+const server_ready_comment_1 = require("../server-ready-comment");
+const file_existence_watchers_1 = require("./file-existence-watchers");
 const serializeMessage = (message) => {
     return `data: ${JSON.stringify(message)}\n\n`;
 };
+let printPortMessageTimeout = null;
 const makeLiveEventsRouter = () => {
     let clients = [];
     const router = (request, response) => {
@@ -17,15 +20,28 @@ const makeLiveEventsRouter = () => {
             response.end();
             return;
         }
-        response.write(serializeMessage({ type: 'init' }));
         const clientId = String(Math.random());
+        response.write(serializeMessage({ type: 'init', clientId }));
         const newClient = {
             id: clientId,
             response,
         };
         clients.push(newClient);
+        if (printPortMessageTimeout) {
+            clearTimeout(printPortMessageTimeout);
+        }
         request.on('close', () => {
+            (0, file_existence_watchers_1.unsubscribeClientFileExistenceWatchers)(clientId);
             clients = clients.filter((client) => client.id !== clientId);
+            // If all clients disconnected, print a comment so user can easily restart it.
+            if (clients.length === 0) {
+                if (printPortMessageTimeout) {
+                    clearTimeout(printPortMessageTimeout);
+                }
+                printPortMessageTimeout = setTimeout(() => {
+                    (0, server_ready_comment_1.printServerReadyComment)('To restart');
+                }, 2500);
+            }
         });
     };
     const sendEventToClient = (event) => {
@@ -39,3 +55,21 @@ const makeLiveEventsRouter = () => {
     };
 };
 exports.makeLiveEventsRouter = makeLiveEventsRouter;
+let liveEventsListener = null;
+const waiters = [];
+const waitForLiveEventsListener = () => {
+    if (liveEventsListener) {
+        return Promise.resolve(liveEventsListener);
+    }
+    return new Promise((resolve) => {
+        waiters.push((list) => {
+            resolve(list);
+        });
+    });
+};
+exports.waitForLiveEventsListener = waitForLiveEventsListener;
+const setLiveEventsListener = (listener) => {
+    liveEventsListener = listener;
+    waiters.forEach((w) => w(listener));
+};
+exports.setLiveEventsListener = setLiveEventsListener;

package/dist/preview-server/parse-body.d.ts

@@ -0,0 +1,2 @@
+import type { IncomingMessage } from 'node:http';
+export declare const parseRequestBody: (req: IncomingMessage) => Promise<unknown>;

package/dist/preview-server/parse-body.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRequestBody = void 0;
+const parseRequestBody = async (req) => {
+    const body = await new Promise((_resolve) => {
+        let data = '';
+        req.on('data', (chunk) => {
+            data += chunk;
+        });
+        req.on('end', () => {
+            _resolve(data.toString());
+        });
+    });
+    return JSON.parse(body);
+};
+exports.parseRequestBody = parseRequestBody;

package/dist/preview-server/project-info.d.ts

@@ -1,4 +1,4 @@
-export declare type ProjectInfo = {
+export type ProjectInfo = {
     videoFile: string | null;
     relativeVideoFile: string | null;
 };

package/dist/preview-server/project-info.js

@@ -4,18 +4,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProjectInfo = void 0;
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
 const getProjectInfo = (remotionRoot) => {
     var _a;
-    const pathsToLookFor = ['src/Video.tsx', 'src/Video.jsx'].map((p) => {
-        return path_1.default.join(remotionRoot, p);
+    const pathsToLookFor = [
+        'src/Root.tsx',
+        'src/Root.jsx',
+        'remotion/Root.tsx',
+        'remotion/Root.jsx',
+        'app/remotion/Root.tsx',
+        'src/Video.tsx',
+        'src/Video.jsx',
+    ].map((p) => {
+        return node_path_1.default.join(remotionRoot, p);
     });
-    const videoFile = (_a = pathsToLookFor.find((p) => (0, fs_1.existsSync)(p))) !== null && _a !== void 0 ? _a : null;
+    const videoFile = (_a = pathsToLookFor.find((p) => (0, node_fs_1.existsSync)(p))) !== null && _a !== void 0 ? _a : null;
     return Promise.resolve({
         videoFile,
         relativeVideoFile: videoFile
-            ? path_1.default.relative(remotionRoot, videoFile)
+            ? node_path_1.default.relative(remotionRoot, videoFile)
             : null,
     });
 };

package/dist/preview-server/public-folder.d.ts

@@ -0,0 +1,12 @@
+import type { StaticFile } from 'remotion';
+export declare const initPublicFolderWatch: ({ publicDir, onUpdate, staticHash, }: {
+    publicDir: string;
+    remotionRoot: string;
+    onUpdate: () => void;
+    staticHash: string;
+}) => void;
+export declare const fetchFolder: ({ publicDir, staticHash, }: {
+    publicDir: string;
+    staticHash: string;
+}) => void;
+export declare const getFiles: () => StaticFile[];

package/dist/preview-server/public-folder.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFiles = exports.fetchFolder = exports.initPublicFolderWatch = void 0;
+const bundler_1 = require("@remotion/bundler");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const env_supports_fs_recursive_1 = require("./env-supports-fs-recursive");
+let files = [];
+const initPublicFolderWatch = ({ publicDir, onUpdate, staticHash, }) => {
+    (0, exports.fetchFolder)({ publicDir, staticHash });
+    watchPublicFolder({ publicDir, onUpdate, staticHash });
+};
+exports.initPublicFolderWatch = initPublicFolderWatch;
+const fetchFolder = ({ publicDir, staticHash, }) => {
+    files = bundler_1.BundlerInternals.readRecursively({
+        folder: '.',
+        startPath: publicDir,
+        staticHash,
+        limit: 1000,
+    }).map((f) => {
+        return {
+            ...f,
+            name: f.name.split(node_path_1.default.sep).join('/'),
+        };
+    });
+};
+exports.fetchFolder = fetchFolder;
+const watchPublicFolder = ({ publicDir, onUpdate, staticHash, }) => {
+    if (!(0, node_fs_1.existsSync)(publicDir)) {
+        const parentDir = node_path_1.default.dirname(publicDir);
+        const onDirChange = () => {
+            if ((0, node_fs_1.existsSync)(publicDir)) {
+                watchPublicFolder({
+                    publicDir,
+                    onUpdate,
+                    staticHash,
+                });
+                watcher.close();
+            }
+        };
+        const watcher = (0, node_fs_1.watch)(parentDir, {}, onDirChange);
+        return;
+    }
+    (0, node_fs_1.watch)(publicDir, { recursive: (0, env_supports_fs_recursive_1.envSupportsFsRecursive)() }, () => {
+        (0, exports.fetchFolder)({ publicDir, staticHash });
+        onUpdate();
+    });
+};
+const getFiles = () => {
+    return files;
+};
+exports.getFiles = getFiles;

package/dist/preview-server/render-queue/get-default-video-contexts.d.ts

@@ -0,0 +1,10 @@
+import type { Codec } from '@remotion/renderer';
+import type { RenderType } from '../../editor/components/RenderModal/RenderModalAdvanced';
+export declare const getDefaultCodecs: ({ defaultCodec, isStill, }: {
+    defaultCodec: Codec;
+    isStill: boolean;
+}) => {
+    initialAudioCodec: Codec;
+    initialVideoCodec: Codec;
+    initialRenderType: RenderType;
+};

package/dist/preview-server/render-queue/get-default-video-contexts.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultCodecs = void 0;
+const client_1 = require("@remotion/renderer/client");
+const getDefaultCodecs = ({ defaultCodec, isStill, }) => {
+    const isAudioCodec = client_1.BrowserSafeApis.isAudioCodec(defaultCodec);
+    return {
+        initialAudioCodec: isAudioCodec ? defaultCodec : 'mp3',
+        initialVideoCodec: isAudioCodec ? 'h264' : defaultCodec,
+        initialRenderType: isStill ? 'still' : isAudioCodec ? 'audio' : 'video',
+    };
+};
+exports.getDefaultCodecs = getDefaultCodecs;