@remotion/studio-server 4.0.91

package/dist/preview-server/dev-middleware/range-parser.js

@@ -0,0 +1,96 @@
+"use strict";
+/*!
+ * range-parser
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRange = void 0;
+function parseRange(size, str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('argument str must be a string');
+    }
+    const index = str.indexOf('=');
+    if (index === -1) {
+        return -2;
+    }
+    // split the range string
+    const arr = str.slice(index + 1).split(',');
+    const ranges = [];
+    // add ranges type
+    ranges.type = str.slice(0, index);
+    // parse all ranges
+    for (let i = 0; i < arr.length; i++) {
+        const range = arr[i].split('-');
+        let start = parseInt(range[0], 10);
+        let end = parseInt(range[1], 10);
+        // -nnn
+        if (isNaN(start)) {
+            start = size - end;
+            end = size - 1;
+            // nnn-
+        }
+        else if (isNaN(end)) {
+            end = size - 1;
+        }
+        // limit last-byte-pos to current length
+        if (end > size - 1) {
+            end = size - 1;
+        }
+        // invalid or unsatisifiable
+        if (isNaN(start) || isNaN(end) || start > end || start < 0) {
+            continue;
+        }
+        // add range
+        ranges.push({
+            start,
+            end,
+        });
+    }
+    if (ranges.length < 1) {
+        return -1;
+    }
+    return combineRanges(ranges);
+}
+exports.parseRange = parseRange;
+function combineRanges(ranges) {
+    const ordered = ranges.map(mapWithIndex).sort(sortByRangeStart);
+    let j = 0;
+    for (let i = 1; i < ordered.length; i++) {
+        const range = ordered[i];
+        const current = ordered[j];
+        if (range.start > current.end + 1) {
+            // next range
+            ordered[++j] = range;
+        }
+        else if (range.end > current.end) {
+            // extend range
+            current.end = range.end;
+            current.index = Math.min(current.index, range.index);
+        }
+    }
+    ordered.length = j + 1;
+    const combined = ordered.sort(sortByRangeIndex).map(mapWithoutIndex);
+    combined.type = ranges.type;
+    return combined;
+}
+function mapWithIndex(range, index) {
+    return {
+        start: range.start,
+        end: range.end,
+        index,
+    };
+}
+function mapWithoutIndex(range) {
+    return {
+        start: range.start,
+        end: range.end,
+    };
+}
+function sortByRangeIndex(a, b) {
+    return a.index - b.index;
+}
+function sortByRangeStart(a, b) {
+    return a.start - b.start;
+}

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

@@ -0,0 +1,3 @@
+import type { webpack } from '@remotion/bundler';
+import type { DevMiddlewareContext } from './types';
+export declare function ready(context: DevMiddlewareContext, callback: (stats: webpack.Stats | undefined) => undefined | Promise<void>): void;

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 @@
+import type { PackageManager } from '@remotion/studio-shared';
+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/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;