@remotion/cli 4.0.0-4x.2 → 4.0.0-alpha.111

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/index.d.ts

@@ -5,4 +5,98 @@
  */
 import type { webpack } from '@remotion/bundler';
 import type { IncomingMessage, ServerResponse } from '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

@@ -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/live-events.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { EventSourceEvent } from '../event-source-events';
+export declare 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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLiveEventsListener = exports.waitForLiveEventsListener = exports.makeLiveEventsRouter = void 0;
+const file_existence_watchers_1 = require("./file-existence-watchers");
+const serializeMessage = (message) => {
+    return `data: ${JSON.stringify(message)}\n\n`;
+};
+const makeLiveEventsRouter = () => {
+    let clients = [];
+    const router = (request, response) => {
+        const headers = {
+            'content-type': 'text/event-stream',
+            connection: 'keep-alive',
+            'cache-control': 'no-cache',
+        };
+        response.writeHead(200, headers);
+        if (request.method === 'OPTIONS') {
+            response.end();
+            return;
+        }
+        const clientId = String(Math.random());
+        response.write(serializeMessage({ type: 'init', clientId }));
+        const newClient = {
+            id: clientId,
+            response,
+        };
+        clients.push(newClient);
+        request.on('close', () => {
+            (0, file_existence_watchers_1.unsubscribeClientFileExistenceWatchers)(clientId);
+            clients = clients.filter((client) => client.id !== clientId);
+        });
+    };
+    const sendEventToClient = (event) => {
+        clients.forEach((client) => {
+            client.response.write(serializeMessage(event));
+        });
+    };
+    return {
+        sendEventToClient,
+        router,
+    };
+};
+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 '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

@@ -2,4 +2,4 @@ export declare type ProjectInfo = {
     videoFile: string | null;
     relativeVideoFile: string | null;
 };
-export declare const getProjectInfo: () => Promise<ProjectInfo>;
+export declare const getProjectInfo: (remotionRoot: string) => Promise<ProjectInfo>;

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

@@ -6,16 +6,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProjectInfo = void 0;
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
-const getProjectInfo = () => {
+const getProjectInfo = (remotionRoot) => {
     var _a;
-    const pathsToLookFor = ['src/Video.tsx', 'src/Video.jsx'].map((p) => {
-        return path_1.default.join(process.cwd(), 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 path_1.default.join(remotionRoot, p);
     });
     const videoFile = (_a = pathsToLookFor.find((p) => (0, fs_1.existsSync)(p))) !== null && _a !== void 0 ? _a : null;
     return Promise.resolve({
         videoFile,
         relativeVideoFile: videoFile
-            ? path_1.default.relative(process.cwd(), videoFile)
+            ? path_1.default.relative(remotionRoot, videoFile)
             : null,
     });
 };

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

@@ -0,0 +1,17 @@
+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 watchPublicFolder: ({ publicDir, onUpdate, staticHash, }: {
+    publicDir: string;
+    onUpdate: () => void;
+    staticHash: string;
+}) => void;
+export declare const getFiles: () => StaticFile[];

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

@@ -0,0 +1,56 @@
+"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.watchPublicFolder = exports.fetchFolder = exports.initPublicFolderWatch = void 0;
+const bundler_1 = require("@remotion/bundler");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const env_supports_fs_recursive_1 = require("./env-supports-fs-recursive");
+let files = [];
+const initPublicFolderWatch = ({ publicDir, onUpdate, staticHash, }) => {
+    (0, exports.fetchFolder)({ publicDir, staticHash });
+    (0, exports.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(path_1.default.sep).join('/'),
+        };
+    });
+};
+exports.fetchFolder = fetchFolder;
+const watchPublicFolder = ({ publicDir, onUpdate, staticHash, }) => {
+    if (!(0, fs_1.existsSync)(publicDir)) {
+        const parentDir = path_1.default.dirname(publicDir);
+        const onDirChange = () => {
+            if ((0, fs_1.existsSync)(publicDir)) {
+                (0, exports.watchPublicFolder)({
+                    publicDir,
+                    onUpdate,
+                    staticHash,
+                });
+                watcher.close();
+            }
+        };
+        const watcher = (0, fs_1.watch)(parentDir, {}, onDirChange);
+        return;
+    }
+    (0, fs_1.watch)(publicDir, { recursive: (0, env_supports_fs_recursive_1.envSupportsFsRecursive)() }, () => {
+        (0, exports.fetchFolder)({ publicDir, staticHash });
+        onUpdate();
+    });
+};
+exports.watchPublicFolder = watchPublicFolder;
+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;

package/dist/preview-server/render-queue/job.d.ts

@@ -0,0 +1,129 @@
+import type { AudioCodec, Codec, makeCancelSignal, PixelFormat, ProResProfile, StillImageFormat, VideoImageFormat } from '@remotion/renderer';
+import type { AggregateRenderProgress } from '../../progress-types';
+import type { RequiredChromiumOptions } from '../../required-chromium-options';
+export declare type BaseRenderProgress = {
+    message: string;
+    value: number;
+};
+declare type RenderJobDynamicStatus = {
+    status: 'done';
+    progress: BaseRenderProgress & AggregateRenderProgress;
+} | {
+    status: 'running';
+    progress: BaseRenderProgress & AggregateRenderProgress;
+} | {
+    status: 'idle';
+} | {
+    status: 'failed';
+    error: {
+        message: string;
+        stack: string | undefined;
+    };
+};
+export declare type JobProgressCallback = (options: BaseRenderProgress & AggregateRenderProgress) => void;
+declare type RenderJobDynamicFields = ({
+    type: 'still';
+    imageFormat: StillImageFormat;
+    quality: number | null;
+    frame: number;
+    scale: number;
+} & RenderJobDynamicStatus) | ({
+    type: 'video';
+    imageFormat: VideoImageFormat;
+    quality: number | null;
+    scale: number;
+    codec: Codec;
+    audioCodec: AudioCodec;
+    concurrency: number;
+    crf: number | null;
+    startFrame: number;
+    endFrame: number;
+    muted: boolean;
+    enforceAudioTrack: boolean;
+    proResProfile: ProResProfile | null;
+    pixelFormat: PixelFormat;
+    audioBitrate: string | null;
+    videoBitrate: string | null;
+    everyNthFrame: number;
+    numberOfGifLoops: number | null;
+    disallowParallelEncoding: boolean;
+} & RenderJobDynamicStatus);
+export declare type RenderJob = {
+    startedAt: number;
+    compositionId: string;
+    id: string;
+    outName: string;
+    deletedOutputLocation: boolean;
+    verbose: boolean;
+    delayRenderTimeout: number;
+    cancelToken: ReturnType<typeof makeCancelSignal>;
+    chromiumOptions: RequiredChromiumOptions;
+    envVariables: Record<string, string>;
+    inputProps: unknown;
+} & RenderJobDynamicFields;
+export declare type RenderJobWithCleanup = RenderJob & {
+    cleanup: (() => void)[];
+};
+declare type AddRenderRequestDynamicFields = {
+    type: 'still';
+    imageFormat: StillImageFormat;
+    quality: number | null;
+    frame: number;
+    scale: number;
+    verbose: boolean;
+} | {
+    type: 'video';
+    codec: Codec;
+    audioCodec: AudioCodec;
+    imageFormat: VideoImageFormat;
+    quality: number | null;
+    scale: number;
+    verbose: boolean;
+    concurrency: number;
+    crf: number | null;
+    startFrame: number;
+    endFrame: number;
+    muted: boolean;
+    enforceAudioTrack: boolean;
+    proResProfile: ProResProfile | null;
+    pixelFormat: PixelFormat;
+    audioBitrate: string | null;
+    videoBitrate: string | null;
+    everyNthFrame: number;
+    numberOfGifLoops: number | null;
+    disallowParallelEncoding: boolean;
+};
+export declare type CancelRenderRequest = {
+    jobId: string;
+};
+export declare type CancelRenderResponse = {};
+export declare type AddRenderRequest = {
+    compositionId: string;
+    outName: string;
+    chromiumOptions: RequiredChromiumOptions;
+    delayRenderTimeout: number;
+    envVariables: Record<string, string>;
+    inputProps: unknown;
+} & AddRenderRequestDynamicFields;
+export declare type RemoveRenderRequest = {
+    jobId: string;
+};
+export declare type OpenInFileExplorerRequest = {
+    directory: string;
+};
+export declare type SubscribeToFileExistenceRequest = {
+    file: string;
+    clientId: string;
+};
+export declare type SubscribeToFileExistenceResponse = {
+    exists: boolean;
+};
+export declare type UnsubscribeFromFileExistenceRequest = {
+    file: string;
+    clientId: string;
+};
+export declare type UpdateDefaultPropsRequest = {
+    compositionId: string;
+    defaultProps: string;
+};
+export {};

package/dist/preview-server/render-queue/job.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/preview-server/render-queue/make-retry-payload.d.ts

@@ -0,0 +1,3 @@
+import type { RenderModalState } from '../../editor/state/modals';
+import type { RenderJob } from './job';
+export declare const makeRetryPayload: (job: RenderJob) => RenderModalState;