@remotion/studio 4.0.80

package/dist/preview-server/dev-middleware/ready.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ready = void 0;
+function ready(context, callback) {
+    if (context.state) {
+        callback(context.stats);
+        return;
+    }
+    context.callbacks.push(callback);
+}
+exports.ready = ready;

package/dist/preview-server/dev-middleware/setup-hooks.d.ts

@@ -0,0 +1,2 @@
+import type { DevMiddlewareContext } from './types';
+export declare function setupHooks(context: DevMiddlewareContext): void;

package/dist/preview-server/dev-middleware/setup-hooks.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupHooks = void 0;
+const renderer_1 = require("@remotion/renderer");
+const no_react_1 = require("remotion/no-react");
+function setupHooks(context) {
+    function invalid() {
+        // We are now in invalid state
+        context.state = false;
+        context.stats = undefined;
+    }
+    function done(stats) {
+        context.state = true;
+        context.stats = stats;
+        // Do the stuff in nextTick, because bundle may be invalidated if a change happened while compiling
+        process.nextTick(() => {
+            const { logger, state, callbacks } = context;
+            // Check if still in valid state
+            if (!state || !stats) {
+                return;
+            }
+            logger.log('Compilation finished');
+            const statsOptions = {
+                preset: 'errors-warnings',
+                colors: renderer_1.RenderInternals.isColorSupported(),
+            };
+            const printedStats = stats.toString(statsOptions);
+            const lines = printedStats
+                .split('\n')
+                .map((a) => a.trimEnd())
+                .filter(no_react_1.NoReactInternals.truthy)
+                .map((a) => {
+                if (a.startsWith('webpack compiled')) {
+                    return `Built in ${stats.endTime - stats.startTime}ms`;
+                }
+                return a;
+            })
+                .join('\n');
+            if (lines) {
+                renderer_1.RenderInternals.Log.info(lines);
+            }
+            context.callbacks = [];
+            callbacks.forEach((callback) => {
+                callback(stats);
+            });
+        });
+    }
+    context.compiler.hooks.watchRun.tap('remotion', invalid);
+    context.compiler.hooks.invalid.tap('remotion', invalid);
+    context.compiler.hooks.done.tap('remotion', done);
+}
+exports.setupHooks = setupHooks;

package/dist/preview-server/dev-middleware/setup-output-filesystem.d.ts

@@ -0,0 +1,2 @@
+import type { DevMiddlewareContext } from './types';
+export declare function setupOutputFileSystem(context: DevMiddlewareContext): void;

package/dist/preview-server/dev-middleware/setup-output-filesystem.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupOutputFileSystem = void 0;
+const memfs_1 = __importDefault(require("memfs"));
+function setupOutputFileSystem(context) {
+    const outputFileSystem = memfs_1.default.createFsFromVolume(new memfs_1.default.Volume());
+    context.compiler.outputFileSystem = outputFileSystem;
+    context.outputFileSystem = outputFileSystem;
+}
+exports.setupOutputFileSystem = setupOutputFileSystem;

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

@@ -0,0 +1,10 @@
+import type { webpack } from '@remotion/bundler';
+import type memfs from 'memfs';
+export type DevMiddlewareContext = {
+    state: boolean;
+    stats: webpack.Stats | undefined;
+    callbacks: ((stats: webpack.Stats) => undefined | Promise<void>)[];
+    compiler: webpack.Compiler;
+    logger: ReturnType<webpack.Compiler['getInfrastructureLogger']>;
+    outputFileSystem: memfs.IFs | undefined;
+};

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

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

package/dist/preview-server/env-supports-fs-recursive.d.ts

@@ -0,0 +1 @@
+export declare const envSupportsFsRecursive: () => boolean;

package/dist/preview-server/env-supports-fs-recursive.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envSupportsFsRecursive = void 0;
+const envSupportsFsRecursive = () => {
+    const nodeVersion = process.version.replace('v', '').split('.');
+    if (process.platform === 'darwin' || process.platform === 'win32') {
+        return true;
+    }
+    if (parseInt(nodeVersion[0], 10) > 19) {
+        return true;
+    }
+    if (parseInt(nodeVersion[0], 10) === 19 &&
+        parseInt(nodeVersion[1], 10) >= 1) {
+        return true;
+    }
+    return false;
+};
+exports.envSupportsFsRecursive = envSupportsFsRecursive;

package/dist/preview-server/file-existence-watchers.d.ts

@@ -0,0 +1,13 @@
+export declare const subscribeToFileExistenceWatchers: ({ file: relativeFile, remotionRoot, clientId, }: {
+    file: string;
+    remotionRoot: string;
+    clientId: string;
+}) => {
+    exists: boolean;
+};
+export declare const unsubscribeFromFileExistenceWatchers: ({ file, remotionRoot, clientId, }: {
+    file: string;
+    remotionRoot: string;
+    clientId: string;
+}) => void;
+export declare const unsubscribeClientFileExistenceWatchers: (clientId: string) => void;

package/dist/preview-server/file-existence-watchers.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsubscribeClientFileExistenceWatchers = exports.unsubscribeFromFileExistenceWatchers = exports.subscribeToFileExistenceWatchers = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const file_watcher_1 = require("../file-watcher");
+const live_events_1 = require("./live-events");
+const fileExistenceWatchers = {};
+const subscribeToFileExistenceWatchers = ({ file: relativeFile, remotionRoot, clientId, }) => {
+    const file = node_path_1.default.resolve(remotionRoot, relativeFile);
+    const { unwatch, exists } = (0, file_watcher_1.installFileWatcher)({
+        file,
+        onChange: (type) => {
+            if (type === 'created') {
+                (0, live_events_1.waitForLiveEventsListener)().then((listener) => {
+                    listener.sendEventToClient({
+                        type: 'watched-file-undeleted',
+                        // Must be relative file because that's what the client expects
+                        file: relativeFile,
+                    });
+                });
+            }
+            if (type === 'deleted') {
+                (0, live_events_1.waitForLiveEventsListener)().then((listener) => {
+                    listener.sendEventToClient({
+                        type: 'watched-file-deleted',
+                        // Must be relative file because that's what the client expects
+                        file: relativeFile,
+                    });
+                });
+            }
+        },
+    });
+    if (!fileExistenceWatchers[clientId]) {
+        fileExistenceWatchers[clientId] = {};
+    }
+    fileExistenceWatchers[clientId][file] = unwatch;
+    return { exists };
+};
+exports.subscribeToFileExistenceWatchers = subscribeToFileExistenceWatchers;
+const unsubscribeFromFileExistenceWatchers = ({ file, remotionRoot, clientId, }) => {
+    var _a, _b;
+    const actualPath = node_path_1.default.resolve(remotionRoot, file);
+    if (!fileExistenceWatchers[clientId]) {
+        return;
+    }
+    (_b = (_a = fileExistenceWatchers[clientId])[actualPath]) === null || _b === void 0 ? void 0 : _b.call(_a);
+    delete fileExistenceWatchers[clientId][actualPath];
+};
+exports.unsubscribeFromFileExistenceWatchers = unsubscribeFromFileExistenceWatchers;
+const unsubscribeClientFileExistenceWatchers = (clientId) => {
+    if (!fileExistenceWatchers[clientId]) {
+        return;
+    }
+    Object.values(fileExistenceWatchers[clientId]).forEach((unwatch) => {
+        unwatch();
+    });
+    delete fileExistenceWatchers[clientId];
+};
+exports.unsubscribeClientFileExistenceWatchers = unsubscribeClientFileExistenceWatchers;

package/dist/preview-server/get-absolute-public-dir.d.ts

@@ -0,0 +1,4 @@
+export declare const getAbsolutePublicDir: ({ userPassedPublicDir, remotionRoot, }: {
+    userPassedPublicDir: string | null;
+    remotionRoot: string;
+}) => string;

package/dist/preview-server/get-absolute-public-dir.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAbsolutePublicDir = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const getAbsolutePublicDir = ({ userPassedPublicDir, remotionRoot, }) => {
+    const publicDir = userPassedPublicDir
+        ? node_path_1.default.resolve(remotionRoot, userPassedPublicDir)
+        : node_path_1.default.join(remotionRoot, 'public');
+    return publicDir;
+};
+exports.getAbsolutePublicDir = getAbsolutePublicDir;

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

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

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

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageManager = exports.lockFilePaths = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.lockFilePaths = [
+    {
+        path: 'package-lock.json',
+        manager: 'npm',
+        installCommand: 'npm i',
+        startCommand: 'npm start',
+    },
+    {
+        path: 'yarn.lock',
+        manager: 'yarn',
+        installCommand: 'yarn add',
+        startCommand: 'yarn start',
+    },
+    {
+        path: 'pnpm-lock.yaml',
+        manager: 'pnpm',
+        installCommand: 'pnpm i',
+        startCommand: 'pnpm start',
+    },
+    {
+        path: 'bun.lockb',
+        manager: 'bun',
+        installCommand: 'bun i',
+        startCommand: 'bun start',
+    },
+];
+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';
+    }
+    if (existingPkgManagers.length > 1) {
+        const error = [
+            `Found multiple lockfiles:`,
+            ...existingPkgManagers.map((m) => {
+                return `- ${m.path}`;
+            }),
+            '',
+            'This can lead to bugs, delete all but one of these files and run this command again.',
+        ].join('\n');
+        throw new Error(error);
+    }
+    return existingPkgManagers[0];
+};
+exports.getPackageManager = getPackageManager;

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

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

package/dist/preview-server/handler.js

@@ -0,0 +1,36 @@
+"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, logLevel, methods, }) => {
+    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,
+            logLevel,
+            methods,
+        });
+        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

@@ -0,0 +1,21 @@
+/// <reference lib="dom" />
+/// <reference lib="dom.iterable" />
+import type { HotMiddlewareMessage } from './types';
+declare function eventSourceWrapper(): {
+    addMessageListener(fn: (msg: MessageEvent) => void): void;
+};
+declare global {
+    interface Window {
+        __whmEventSourceWrapper: {
+            [key: string]: ReturnType<typeof eventSourceWrapper>;
+        };
+        __webpack_hot_middleware_reporter__: Reporter;
+    }
+}
+type Reporter = ReturnType<typeof createReporter>;
+declare function createReporter(): {
+    cleanProblemsCache(): void;
+    problems(type: 'errors' | 'warnings', obj: HotMiddlewareMessage): boolean;
+    success: () => undefined;
+};
+export {};

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

@@ -0,0 +1,179 @@
+"use strict";
+/// <reference lib="dom" />
+/// <reference lib="dom.iterable" />
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+/**
+ * Source code is adapted from
+ * 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 types_1 = require("./types");
+if (typeof window === 'undefined') {
+    // do nothing
+}
+else if (typeof window.EventSource === 'undefined') {
+    console.warn('Unsupported browser: You need a browser that supports EventSource ');
+}
+else {
+    connect();
+}
+function eventSourceWrapper() {
+    let source;
+    let lastActivity = Date.now();
+    const listeners = [];
+    init();
+    const timer = setInterval(() => {
+        if (Date.now() - lastActivity > types_1.hotMiddlewareOptions.timeout) {
+            handleDisconnect();
+        }
+    }, types_1.hotMiddlewareOptions.timeout / 2);
+    function init() {
+        source = new window.EventSource(types_1.hotMiddlewareOptions.path);
+        source.onopen = handleOnline;
+        source.onerror = handleDisconnect;
+        source.onmessage = handleMessage;
+    }
+    function handleOnline() {
+        lastActivity = Date.now();
+    }
+    function handleMessage(event) {
+        lastActivity = Date.now();
+        for (let i = 0; i < listeners.length; i++) {
+            listeners[i](event);
+        }
+    }
+    function handleDisconnect() {
+        clearInterval(timer);
+        source.close();
+        setTimeout(init, 1000);
+    }
+    return {
+        addMessageListener(fn) {
+            listeners.push(fn);
+        },
+    };
+}
+function getEventSourceWrapper() {
+    if (!window.__whmEventSourceWrapper) {
+        window.__whmEventSourceWrapper = {};
+    }
+    if (!window.__whmEventSourceWrapper[types_1.hotMiddlewareOptions.path]) {
+        // cache the wrapper for other entries loaded on
+        // the same page with the same hotMiddlewareOptions.path
+        window.__whmEventSourceWrapper[types_1.hotMiddlewareOptions.path] =
+            eventSourceWrapper();
+    }
+    return window.__whmEventSourceWrapper[types_1.hotMiddlewareOptions.path];
+}
+function connect() {
+    getEventSourceWrapper().addMessageListener(handleMessage);
+    function handleMessage(event) {
+        if (event.data === '\uD83D\uDC93') {
+            return;
+        }
+        try {
+            processMessage(JSON.parse(event.data));
+        }
+        catch (ex) {
+            if (types_1.hotMiddlewareOptions.warn) {
+                console.warn('Invalid HMR message: ' + event.data + '\n' + ex);
+            }
+        }
+    }
+}
+// the reporter needs to be a singleton on the page
+// in case the client is being used by multiple bundles
+// we only want to report once.
+// all the errors will go to all clients
+const singletonKey = '__webpack_hot_middleware_reporter__';
+let reporter;
+if (typeof window !== 'undefined') {
+    if (!window[singletonKey]) {
+        window[singletonKey] = createReporter();
+    }
+    reporter = window[singletonKey];
+}
+function createReporter() {
+    const styles = {
+        errors: 'color: #ff0000;',
+        warnings: 'color: #999933;',
+    };
+    let previousProblems = null;
+    function log(type, obj) {
+        if (obj.action === 'building') {
+            console.log('[Fast Refresh] Building');
+            return;
+        }
+        const newProblems = obj[type]
+            .map((msg) => {
+            return (0, ansi_split_1.stripAnsi)(msg);
+        })
+            .join('\n');
+        if (previousProblems === newProblems) {
+            return;
+        }
+        previousProblems = newProblems;
+        const style = styles[type];
+        const name = obj.name ? "'" + obj.name + "' " : '';
+        const title = '[Fast Refresh] bundle ' + name + 'has ' + obj[type].length + ' ' + type;
+        // NOTE: console.warn or console.error will print the stack trace
+        // which isn't helpful here, so using console.log to escape it.
+        if (console.group && console.groupEnd) {
+            console.group('%c' + title, style);
+            console.log('%c' + newProblems, style);
+            console.groupEnd();
+        }
+        else {
+            console.log('%c' + title + '\n\t%c' + newProblems.replace(/\n/g, '\n\t'), style + 'font-weight: bold;', style + 'font-weight: normal;');
+        }
+    }
+    return {
+        cleanProblemsCache() {
+            previousProblems = null;
+        },
+        problems(type, obj) {
+            if (types_1.hotMiddlewareOptions.warn) {
+                log(type, obj);
+            }
+            return true;
+        },
+        success: () => undefined,
+    };
+}
+function processMessage(obj) {
+    var _a, _b;
+    switch (obj.action) {
+        case 'building':
+            (_a = window.remotion_isBuilding) === null || _a === void 0 ? void 0 : _a.call(window);
+            break;
+        case 'sync':
+        case 'built': {
+            let applyUpdate = true;
+            if (obj.errors.length > 0) {
+                if (reporter)
+                    reporter.problems('errors', obj);
+                applyUpdate = false;
+            }
+            else if (obj.warnings.length > 0) {
+                if (reporter) {
+                    const overlayShown = reporter.problems('warnings', obj);
+                    applyUpdate = overlayShown;
+                }
+            }
+            else if (reporter) {
+                reporter.cleanProblemsCache();
+                reporter.success();
+            }
+            if (applyUpdate) {
+                (_b = window.remotion_finishedBuilding) === null || _b === void 0 ? void 0 : _b.call(window);
+                (0, process_update_1.processUpdate)(obj.hash, obj.modules, types_1.hotMiddlewareOptions);
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}

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

@@ -0,0 +1,102 @@
+/**
+ * Source code is adapted from
+ * https://github.com/webpack-contrib/webpack-hot-middleware#readme
+ * and rewritten in TypeScript. This file is MIT licensed
+ */
+import type { webpack } from '@remotion/bundler';
+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;