@remotion/studio-server 4.0.91

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

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * Source code is adapted from
+ * https://github.com/webpack-contrib/webpack-hot-middleware#readme
+ * and rewritten in TypeScript. This file is MIT licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webpackHotMiddleware = void 0;
+const renderer_1 = require("@remotion/renderer");
+const studio_shared_1 = require("@remotion/studio-shared");
+const node_url_1 = require("node:url");
+const pathMatch = function (url, path) {
+    try {
+        return (0, node_url_1.parse)(url).pathname === path;
+    }
+    catch (e) {
+        return false;
+    }
+};
+const webpackHotMiddleware = (compiler) => {
+    const eventStream = createEventStream(studio_shared_1.hotMiddlewareOptions.heartbeat);
+    let latestStats = null;
+    compiler.hooks.invalid.tap('remotion', onInvalid);
+    compiler.hooks.done.tap('remotion', onDone);
+    function onInvalid() {
+        latestStats = null;
+        renderer_1.RenderInternals.Log.info('Building...');
+        eventStream === null || eventStream === void 0 ? void 0 : eventStream.publish({
+            action: 'building',
+        });
+    }
+    function onDone(statsResult) {
+        // Keep hold of latest stats so they can be propagated to new clients
+        latestStats = statsResult;
+        publishStats('built', latestStats, eventStream);
+    }
+    const middleware = function (req, res, next) {
+        if (!pathMatch(req.url, studio_shared_1.hotMiddlewareOptions.path))
+            return next();
+        eventStream === null || eventStream === void 0 ? void 0 : eventStream.handler(req, res);
+        if (latestStats) {
+            publishStats('sync', latestStats, eventStream);
+        }
+    };
+    return middleware;
+};
+exports.webpackHotMiddleware = webpackHotMiddleware;
+function createEventStream(heartbeat) {
+    let clientId = 0;
+    let clients = {};
+    function everyClient(fn) {
+        Object.keys(clients).forEach((id) => {
+            fn(clients[id]);
+        });
+    }
+    const interval = setInterval(() => {
+        everyClient((client) => {
+            client.write('data: \uD83D\uDC93\n\n');
+        });
+    }, heartbeat).unref();
+    return {
+        close() {
+            clearInterval(interval);
+            everyClient((client) => {
+                if (!client.finished)
+                    client.end();
+            });
+            clients = {};
+        },
+        handler(req, res) {
+            const headers = {
+                'Access-Control-Allow-Origin': '*',
+                'Content-Type': 'text/event-stream;charset=utf-8',
+                'Cache-Control': 'no-cache, no-transform',
+            };
+            const isHttp1 = !(parseInt(req.httpVersion, 10) >= 2);
+            if (isHttp1) {
+                req.socket.setKeepAlive(true);
+                Object.assign(headers, {
+                    Connection: 'keep-alive',
+                });
+            }
+            res.writeHead(200, headers);
+            res.write('\n');
+            const id = clientId++;
+            clients[id] = res;
+            req.on('close', () => {
+                if (!res.finished)
+                    res.end();
+                delete clients[id];
+            });
+        },
+        publish(payload) {
+            everyClient((client) => {
+                client.write('data: ' + JSON.stringify(payload) + '\n\n');
+            });
+        },
+    };
+}
+function publishStats(action, statsResult, eventStream) {
+    const stats = statsResult.toJson({
+        all: false,
+        cached: true,
+        children: true,
+        modules: true,
+        timings: true,
+        hash: true,
+    });
+    // For multi-compiler, stats will be an object with a 'children' array of stats
+    const bundles = extractBundles(stats);
+    bundles.forEach((_stats) => {
+        let name = _stats.name || '';
+        // Fallback to compilation name in case of 1 bundle (if it exists)
+        if (bundles.length === 1 && !name && statsResult.compilation) {
+            name = statsResult.compilation.name || '';
+        }
+        eventStream === null || eventStream === void 0 ? void 0 : eventStream.publish({
+            name,
+            action,
+            time: _stats.time,
+            hash: _stats.hash,
+            warnings: _stats.warnings || [],
+            errors: _stats.errors || [],
+            modules: buildModuleMap(_stats.modules),
+        });
+    });
+}
+function extractBundles(stats) {
+    var _a;
+    // Stats has modules, single bundle
+    if (stats.modules)
+        return [stats];
+    // Stats has children, multiple bundles
+    if ((_a = stats.children) === null || _a === void 0 ? void 0 : _a.length)
+        return stats.children;
+    // Not sure, assume single
+    return [stats];
+}
+function buildModuleMap(modules) {
+    const map = {};
+    if (!modules) {
+        return map;
+    }
+    modules.forEach((module) => {
+        const id = module.id;
+        map[id] = module.name;
+    });
+    return map;
+}

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

@@ -0,0 +1,2 @@
+import type { webpack } from '@remotion/bundler';
+export type WebpackStats = ReturnType<webpack.Stats['toJson']>;

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

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

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

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import type { EventSourceEvent } from '@remotion/studio-shared';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLiveEventsListener = exports.waitForLiveEventsListener = exports.makeLiveEventsRouter = void 0;
+const server_ready_1 = require("../server-ready");
+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) => {
+        const headers = {
+            'content-type': 'text/event-stream;charset=utf-8',
+            connection: 'keep-alive',
+            'cache-control': 'no-cache',
+        };
+        response.writeHead(200, headers);
+        response.write('\n');
+        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);
+        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_1.printServerReadyComment)('To restart');
+                }, 2500);
+            }
+        });
+    };
+    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 '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

@@ -0,0 +1,2 @@
+import type { ProjectInfo } from '@remotion/studio-shared';
+export declare const getProjectInfo: (remotionRoot: string) => Promise<ProjectInfo>;

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

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

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,58 @@
+"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: 10000,
+    }).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,
+                });
+                onUpdate();
+                watcher.close();
+            }
+        };
+        const watcher = (0, node_fs_1.watch)(parentDir, {}, onDirChange);
+        return;
+    }
+    // Known bug: If whole public folder is deleted, this will not be called on macOS.
+    // This is not severe, so a wontfix for now.
+    (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/routes/add-render.d.ts

@@ -0,0 +1,3 @@
+import type { AddRenderRequest } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
+export declare const handleAddRender: ApiHandler<AddRenderRequest, undefined>;

package/dist/preview-server/routes/add-render.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAddRender = void 0;
+const renderer_1 = require("@remotion/renderer");
+const handleAddRender = ({ input, entryPoint, remotionRoot, logLevel, methods: { addJob }, }) => {
+    const id = String(Math.random()).replace('0.', '');
+    if (input.type === 'video') {
+        addJob({
+            entryPoint,
+            remotionRoot,
+            job: {
+                cleanup: [],
+                codec: input.codec,
+                audioCodec: input.audioCodec,
+                compositionId: input.compositionId,
+                deletedOutputLocation: false,
+                type: 'video',
+                status: 'idle',
+                id,
+                imageFormat: input.imageFormat,
+                outName: input.outName,
+                jpegQuality: input.jpegQuality,
+                scale: input.scale,
+                startedAt: Date.now(),
+                logLevel: input.logLevel,
+                cancelToken: (0, renderer_1.makeCancelSignal)(),
+                concurrency: input.concurrency,
+                crf: input.crf,
+                endFrame: input.endFrame,
+                startFrame: input.startFrame,
+                muted: input.muted,
+                enforceAudioTrack: input.enforceAudioTrack,
+                proResProfile: input.proResProfile,
+                x264Preset: input.x264Preset,
+                pixelFormat: input.pixelFormat,
+                audioBitrate: input.audioBitrate,
+                videoBitrate: input.videoBitrate,
+                encodingMaxRate: input.encodingMaxRate,
+                encodingBufferSize: input.encodingBufferSize,
+                everyNthFrame: input.everyNthFrame,
+                numberOfGifLoops: input.numberOfGifLoops,
+                delayRenderTimeout: input.delayRenderTimeout,
+                disallowParallelEncoding: input.disallowParallelEncoding,
+                chromiumOptions: input.chromiumOptions,
+                envVariables: input.envVariables,
+                serializedInputPropsWithCustomSchema: input.serializedInputPropsWithCustomSchema,
+                offthreadVideoCacheSizeInBytes: input.offthreadVideoCacheSizeInBytes,
+                colorSpace: input.colorSpace,
+                multiProcessOnLinux: input.multiProcessOnLinux,
+                beepOnFinish: input.beepOnFinish,
+                repro: input.repro,
+            },
+            logLevel,
+        });
+    }
+    if (input.type === 'sequence') {
+        addJob({
+            entryPoint,
+            remotionRoot,
+            job: {
+                cleanup: [],
+                compositionId: input.compositionId,
+                deletedOutputLocation: false,
+                type: 'sequence',
+                status: 'idle',
+                id,
+                imageFormat: input.imageFormat,
+                outName: input.outName,
+                jpegQuality: input.jpegQuality,
+                scale: input.scale,
+                startedAt: Date.now(),
+                logLevel: input.logLevel,
+                cancelToken: (0, renderer_1.makeCancelSignal)(),
+                concurrency: input.concurrency,
+                endFrame: input.endFrame,
+                startFrame: input.startFrame,
+                delayRenderTimeout: input.delayRenderTimeout,
+                chromiumOptions: input.chromiumOptions,
+                envVariables: input.envVariables,
+                serializedInputPropsWithCustomSchema: input.serializedInputPropsWithCustomSchema,
+                offthreadVideoCacheSizeInBytes: input.offthreadVideoCacheSizeInBytes,
+                multiProcessOnLinux: input.multiProcessOnLinux,
+                beepOnFinish: input.beepOnFinish,
+                repro: input.repro,
+            },
+            logLevel,
+        });
+    }
+    if (input.type === 'still') {
+        addJob({
+            job: {
+                compositionId: input.compositionId,
+                id: String(Math.random()).replace('0.', ''),
+                startedAt: Date.now(),
+                type: 'still',
+                outName: input.outName,
+                status: 'idle',
+                imageFormat: input.imageFormat,
+                jpegQuality: input.jpegQuality,
+                frame: input.frame,
+                scale: input.scale,
+                cleanup: [],
+                deletedOutputLocation: false,
+                logLevel: input.logLevel,
+                cancelToken: (0, renderer_1.makeCancelSignal)(),
+                chromiumOptions: input.chromiumOptions,
+                delayRenderTimeout: input.delayRenderTimeout,
+                envVariables: input.envVariables,
+                serializedInputPropsWithCustomSchema: input.serializedInputPropsWithCustomSchema,
+                offthreadVideoCacheSizeInBytes: input.offthreadVideoCacheSizeInBytes,
+                multiProcessOnLinux: input.multiProcessOnLinux,
+                beepOnFinish: input.beepOnFinish,
+                repro: false,
+            },
+            entryPoint,
+            remotionRoot,
+            logLevel,
+        });
+    }
+    return Promise.resolve(undefined);
+};
+exports.handleAddRender = handleAddRender;

package/dist/preview-server/routes/can-update-default-props.d.ts

@@ -0,0 +1,4 @@
+import type { CanUpdateDefaultPropsRequest, CanUpdateDefaultPropsResponse } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
+export declare const checkIfTypeScriptFile: (file: string) => void;
+export declare const canUpdateDefaultPropsHandler: ApiHandler<CanUpdateDefaultPropsRequest, CanUpdateDefaultPropsResponse>;

package/dist/preview-server/routes/can-update-default-props.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canUpdateDefaultPropsHandler = exports.checkIfTypeScriptFile = void 0;
+const node_fs_1 = require("node:fs");
+const update_default_props_1 = require("../../codemods/update-default-props");
+const project_info_1 = require("../project-info");
+const checkIfTypeScriptFile = (file) => {
+    if (!file.endsWith('.tsx') &&
+        !file.endsWith('.ts') &&
+        !file.endsWith('.mtsx') &&
+        !file.endsWith('.mts')) {
+        throw new Error('Cannot update default props for non-TypeScript files');
+    }
+};
+exports.checkIfTypeScriptFile = checkIfTypeScriptFile;
+const canUpdateDefaultPropsHandler = async ({ input: { compositionId }, remotionRoot }) => {
+    try {
+        const projectInfo = await (0, project_info_1.getProjectInfo)(remotionRoot);
+        if (!projectInfo.videoFile) {
+            throw new Error('Cannot find root file in project');
+        }
+        (0, exports.checkIfTypeScriptFile)(projectInfo.videoFile);
+        await (0, update_default_props_1.updateDefaultProps)({
+            compositionId,
+            input: (0, node_fs_1.readFileSync)(projectInfo.videoFile, 'utf-8'),
+            newDefaultProps: {},
+            enumPaths: [],
+        });
+        return {
+            canUpdate: true,
+        };
+    }
+    catch (err) {
+        return {
+            canUpdate: false,
+            reason: err.message,
+        };
+    }
+};
+exports.canUpdateDefaultPropsHandler = canUpdateDefaultPropsHandler;

package/dist/preview-server/routes/cancel-render.d.ts

@@ -0,0 +1,3 @@
+import type { CancelRenderRequest, CancelRenderResponse } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
+export declare const handleCancelRender: ApiHandler<CancelRenderRequest, CancelRenderResponse>;

package/dist/preview-server/routes/cancel-render.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCancelRender = void 0;
+const handleCancelRender = ({ input: { jobId }, methods: { cancelJob } }) => {
+    cancelJob(jobId);
+    return Promise.resolve({});
+};
+exports.handleCancelRender = handleCancelRender;

package/dist/preview-server/routes/copy-still-to-clipboard-handler.d.ts

@@ -0,0 +1,3 @@
+import type { CopyStillToClipboardRequest } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
+export declare const handleCopyStillToClipboard: ApiHandler<CopyStillToClipboardRequest, void>;

package/dist/preview-server/routes/copy-still-to-clipboard-handler.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCopyStillToClipboard = void 0;
+const renderer_1 = require("@remotion/renderer");
+const path_1 = __importDefault(require("path"));
+const handleCopyStillToClipboard = ({ input: { outName }, remotionRoot }) => {
+    const resolved = path_1.default.resolve(remotionRoot, outName);
+    const relativeToProcessCwd = path_1.default.relative(remotionRoot, resolved);
+    if (relativeToProcessCwd.startsWith('..')) {
+        throw new Error(`Not allowed to open ${relativeToProcessCwd}`);
+    }
+    return renderer_1.RenderInternals.copyImageToClipboard(resolved, 'info');
+};
+exports.handleCopyStillToClipboard = handleCopyStillToClipboard;

package/dist/preview-server/routes/open-in-file-explorer.d.ts

@@ -0,0 +1,3 @@
+import type { OpenInFileExplorerRequest } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
+export declare const handleOpenInFileExplorer: ApiHandler<OpenInFileExplorerRequest, void>;

package/dist/preview-server/routes/open-in-file-explorer.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOpenInFileExplorer = void 0;
+const open_directory_in_finder_1 = require("../../open-directory-in-finder");
+const handleOpenInFileExplorer = ({ input: { directory }, remotionRoot }) => {
+    return (0, open_directory_in_finder_1.openDirectoryInFinder)(directory, remotionRoot);
+};
+exports.handleOpenInFileExplorer = handleOpenInFileExplorer;

package/dist/preview-server/routes/remove-render.d.ts

@@ -0,0 +1,3 @@
+import type { RemoveRenderRequest } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
+export declare const handleRemoveRender: ApiHandler<RemoveRenderRequest, undefined>;

package/dist/preview-server/routes/remove-render.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRemoveRender = void 0;
+const handleRemoveRender = ({ input: { jobId }, methods: { removeJob }, }) => {
+    removeJob(jobId);
+    return Promise.resolve(undefined);
+};
+exports.handleRemoveRender = handleRemoveRender;

package/dist/preview-server/routes/subscribe-to-file-existence.d.ts

@@ -0,0 +1,3 @@
+import type { SubscribeToFileExistenceRequest, SubscribeToFileExistenceResponse } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
+export declare const subscribeToFileExistence: ApiHandler<SubscribeToFileExistenceRequest, SubscribeToFileExistenceResponse>;

package/dist/preview-server/routes/subscribe-to-file-existence.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribeToFileExistence = void 0;
+const file_existence_watchers_1 = require("../file-existence-watchers");
+const subscribeToFileExistence = ({ input: { file, clientId }, remotionRoot }) => {
+    const { exists } = (0, file_existence_watchers_1.subscribeToFileExistenceWatchers)({
+        file,
+        remotionRoot,
+        clientId,
+    });
+    return Promise.resolve({ exists });
+};
+exports.subscribeToFileExistence = subscribeToFileExistence;

package/dist/preview-server/routes/unsubscribe-from-file-existence.d.ts

@@ -0,0 +1,3 @@
+import type { UnsubscribeFromFileExistenceRequest } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
+export declare const unsubscribeFromFileExistence: ApiHandler<UnsubscribeFromFileExistenceRequest, undefined>;

package/dist/preview-server/routes/unsubscribe-from-file-existence.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsubscribeFromFileExistence = void 0;
+const file_existence_watchers_1 = require("../file-existence-watchers");
+const unsubscribeFromFileExistence = ({ input, remotionRoot }) => {
+    (0, file_existence_watchers_1.unsubscribeFromFileExistenceWatchers)({
+        file: input.file,
+        clientId: input.clientId,
+        remotionRoot,
+    });
+    return Promise.resolve(undefined);
+};
+exports.unsubscribeFromFileExistence = unsubscribeFromFileExistence;

package/dist/preview-server/routes/update-available.d.ts

@@ -0,0 +1,3 @@
+import type { UpdateAvailableRequest, UpdateAvailableResponse } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
+export declare const handleUpdate: ApiHandler<UpdateAvailableRequest, UpdateAvailableResponse>;