@remotion/studio 4.0.80

package/dist/render-queue/queue.js

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancelJob = exports.removeJob = exports.addJob = exports.getRenderQueue = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const chalk_1 = require("../../chalk");
+const config_1 = require("../../config");
+const file_watcher_1 = require("../../file-watcher");
+const log_1 = require("../../log");
+const print_error_1 = require("../../print-error");
+const progress_types_1 = require("../../progress-types");
+const live_events_1 = require("../live-events");
+const process_still_1 = require("./process-still");
+const process_video_1 = require("./process-video");
+let jobQueue = [];
+const updateJob = (id, updater) => {
+    jobQueue = jobQueue.map((j) => {
+        if (id === j.id) {
+            return updater(j);
+        }
+        return j;
+    });
+    notifyClientsOfJobUpdate();
+};
+const getRenderQueue = () => {
+    return jobQueue.map((j) => {
+        const { cleanup, ...rest } = j;
+        return rest;
+    });
+};
+exports.getRenderQueue = getRenderQueue;
+const notifyClientsOfJobUpdate = () => {
+    (0, live_events_1.waitForLiveEventsListener)().then((listener) => {
+        listener.sendEventToClient({
+            type: 'render-queue-updated',
+            queue: (0, exports.getRenderQueue)(),
+        });
+    });
+};
+const processJob = async ({ job, remotionRoot, entryPoint, onProgress, addCleanupCallback, logLevel, }) => {
+    if (job.type === 'still') {
+        await (0, process_still_1.processStill)({
+            job,
+            remotionRoot,
+            entryPoint,
+            onProgress,
+            addCleanupCallback,
+        });
+        return;
+    }
+    if (job.type === 'video' || job.type === 'sequence') {
+        await (0, process_video_1.processVideoJob)({
+            job,
+            remotionRoot,
+            entryPoint,
+            onProgress,
+            addCleanupCallback,
+            logLevel,
+        });
+        return;
+    }
+    throw new Error(`Unknown job ${JSON.stringify(job)}`);
+};
+const addJob = ({ job, entryPoint, remotionRoot, logLevel, }) => {
+    jobQueue.push(job);
+    processJobIfPossible({ entryPoint, remotionRoot, logLevel });
+    notifyClientsOfJobUpdate();
+};
+exports.addJob = addJob;
+const removeJob = (jobId) => {
+    jobQueue = jobQueue.filter((job) => {
+        if (job.id === jobId) {
+            job.cleanup.forEach((c) => {
+                c();
+            });
+            return false;
+        }
+        return true;
+    });
+    notifyClientsOfJobUpdate();
+};
+exports.removeJob = removeJob;
+const cancelJob = (jobId) => {
+    for (const job of jobQueue) {
+        if (job.id === jobId) {
+            if (job.status !== 'running') {
+                throw new Error('Job is not running');
+            }
+            job.cancelToken.cancel();
+            break;
+        }
+    }
+};
+exports.cancelJob = cancelJob;
+const processJobIfPossible = async ({ remotionRoot, entryPoint, logLevel, }) => {
+    const runningJob = jobQueue.find((q) => {
+        return q.status === 'running';
+    });
+    if (runningJob) {
+        return;
+    }
+    const nextJob = jobQueue.find((q) => {
+        return q.status === 'idle';
+    });
+    if (!nextJob) {
+        return;
+    }
+    const jobCleanups = [];
+    try {
+        updateJob(nextJob.id, (job) => {
+            return {
+                ...job,
+                status: 'running',
+                progress: {
+                    value: 0,
+                    message: 'Starting job...',
+                    ...(0, progress_types_1.initialAggregateRenderProgress)(),
+                },
+            };
+        });
+        const startTime = Date.now();
+        log_1.Log.info(chalk_1.chalk.gray('╭─ Starting render '));
+        let lastProgress = null;
+        await processJob({
+            job: nextJob,
+            entryPoint,
+            remotionRoot,
+            onProgress: (progress) => {
+                updateJob(nextJob.id, (job) => {
+                    lastProgress = progress;
+                    // Ignore late callbacks of progress updates after cancelling
+                    if (job.status === 'failed' || job.status === 'done') {
+                        return job;
+                    }
+                    if (job.type === 'still') {
+                        return {
+                            ...job,
+                            status: 'running',
+                            progress,
+                        };
+                    }
+                    if (job.type === 'video') {
+                        return {
+                            ...job,
+                            status: 'running',
+                            progress,
+                        };
+                    }
+                    if (job.type === 'sequence') {
+                        return {
+                            ...job,
+                            status: 'running',
+                            progress,
+                        };
+                    }
+                    throw new Error('Unknown job type');
+                });
+            },
+            addCleanupCallback: (cleanup) => {
+                jobCleanups.push(cleanup);
+            },
+            logLevel,
+        });
+        log_1.Log.info(chalk_1.chalk.gray('╰─ Done in ' + (Date.now() - startTime) + 'ms.'));
+        const { unwatch } = (0, file_watcher_1.installFileWatcher)({
+            file: node_path_1.default.resolve(remotionRoot, nextJob.outName),
+            onChange: (type) => {
+                if (type === 'created') {
+                    updateJob(nextJob.id, (job) => ({
+                        ...job,
+                        deletedOutputLocation: false,
+                    }));
+                }
+                if (type === 'deleted') {
+                    updateJob(nextJob.id, (job) => ({
+                        ...job,
+                        deletedOutputLocation: true,
+                    }));
+                }
+            },
+        });
+        updateJob(nextJob.id, (job) => {
+            if (!lastProgress) {
+                throw new Error('expected progress');
+            }
+            return {
+                ...job,
+                status: 'done',
+                cleanup: [...job.cleanup, unwatch],
+                progress: { message: 'Done', value: 1, ...lastProgress },
+            };
+        });
+    }
+    catch (err) {
+        log_1.Log.error(chalk_1.chalk.gray('╰─ '), chalk_1.chalk.red('Failed to render'));
+        updateJob(nextJob.id, (job) => {
+            return {
+                ...job,
+                status: 'failed',
+                error: {
+                    message: err.message,
+                    stack: err.stack,
+                },
+            };
+        });
+        await (0, print_error_1.printError)(err, config_1.ConfigInternals.Logging.getLogLevel());
+        (0, live_events_1.waitForLiveEventsListener)().then((listener) => {
+            listener.sendEventToClient({
+                type: 'render-job-failed',
+                compositionId: nextJob.compositionId,
+                error: err,
+            });
+        });
+    }
+    finally {
+        await Promise.all(jobCleanups.map((c) => c()));
+    }
+    processJobIfPossible({ remotionRoot, entryPoint, logLevel });
+};

package/dist/required-chromium-options.d.ts

@@ -0,0 +1,3 @@
+import type { ChromiumOptions, OpenGlRenderer } from '@remotion/renderer';
+export type RequiredChromiumOptions = Required<ChromiumOptions>;
+export type UiOpenGlOptions = OpenGlRenderer | 'default';

package/dist/required-chromium-options.js

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

package/dist/routes.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import type { RenderDefaults } from '@remotion/bundler/dist/index-html';
+import type { LogLevel } from '@remotion/renderer';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { QueueMethods } from './preview-server/api-types';
+import type { RenderJob } from './preview-server/job';
+import type { LiveEventsServer } from './preview-server/live-events';
+export declare const handleRoutes: ({ staticHash, staticHashPrefix, outputHash, outputHashPrefix, request, response, liveEventsServer, getCurrentInputProps, getEnvVariables, remotionRoot, entryPoint, publicDir, logLevel, getRenderQueue, getRenderDefaults, numberOfAudioTags, queueMethods: methods, }: {
+    staticHash: string;
+    staticHashPrefix: string;
+    outputHash: string;
+    outputHashPrefix: string;
+    request: IncomingMessage;
+    response: ServerResponse;
+    liveEventsServer: LiveEventsServer;
+    getCurrentInputProps: () => object;
+    getEnvVariables: () => Record<string, string>;
+    remotionRoot: string;
+    entryPoint: string;
+    publicDir: string;
+    logLevel: LogLevel;
+    getRenderQueue: () => RenderJob[];
+    getRenderDefaults: () => RenderDefaults;
+    numberOfAudioTags: number;
+    queueMethods: QueueMethods;
+}) => void | Promise<void> | Promise<ServerResponse<IncomingMessage> | undefined>;

package/dist/routes.js

@@ -0,0 +1,229 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRoutes = void 0;
+const bundler_1 = require("@remotion/bundler");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importStar(require("node:path"));
+const node_url_1 = require("node:url");
+const get_file_source_1 = require("./error-overlay/react-overlay/utils/get-file-source");
+const open_in_editor_1 = require("./error-overlay/react-overlay/utils/open-in-editor");
+const source_map_endpoint_1 = require("./error-overlay/react-overlay/utils/source-map-endpoint");
+const api_routes_1 = require("./preview-server/api-routes");
+const get_package_manager_1 = require("./preview-server/get-package-manager");
+const handler_1 = require("./preview-server/handler");
+const parse_body_1 = require("./preview-server/parse-body");
+const project_info_1 = require("./preview-server/project-info");
+const public_folder_1 = require("./preview-server/public-folder");
+const serve_static_1 = require("./preview-server/serve-static");
+const editorGuess = (0, open_in_editor_1.guessEditor)();
+const static404 = (response) => {
+    response.writeHead(404);
+    response.end('The static/ prefix has been changed, this URL is no longer valid.');
+};
+const output404 = (response) => {
+    response.writeHead(404);
+    response.end('The outputs/ prefix has been changed, this URL is no longer valid.');
+};
+const handleFallback = async ({ remotionRoot, hash, response, getCurrentInputProps, getEnvVariables, publicDir, getRenderQueue, getRenderDefaults, numberOfAudioTags, }) => {
+    const [edit] = await editorGuess;
+    const displayName = (0, open_in_editor_1.getDisplayNameForEditor)(edit ? edit.command : null);
+    response.setHeader('content-type', 'text/html');
+    response.writeHead(200);
+    const packageManager = (0, get_package_manager_1.getPackageManager)(remotionRoot, undefined);
+    (0, public_folder_1.fetchFolder)({ publicDir, staticHash: hash });
+    response.end(bundler_1.BundlerInternals.indexHtml({
+        staticHash: hash,
+        baseDir: '/',
+        editorName: displayName,
+        envVariables: getEnvVariables(),
+        inputProps: getCurrentInputProps(),
+        remotionRoot,
+        studioServerCommand: packageManager === 'unknown' ? null : packageManager.startCommand,
+        renderQueue: getRenderQueue(),
+        numberOfAudioTags,
+        publicFiles: (0, public_folder_1.getFiles)(),
+        includeFavicon: true,
+        title: 'Remotion Studio',
+        renderDefaults: getRenderDefaults(),
+        publicFolderExists: (0, node_fs_1.existsSync)(publicDir) ? publicDir : null,
+    }));
+};
+const handleProjectInfo = async (remotionRoot, _, response) => {
+    const data = await (0, project_info_1.getProjectInfo)(remotionRoot);
+    response.setHeader('content-type', 'application/json');
+    response.writeHead(200);
+    response.end(JSON.stringify(data));
+};
+const handleFileSource = async ({ method, remotionRoot, search, response, }) => {
+    if (method === 'OPTIONS') {
+        response.writeHead(200);
+        response.end();
+        return;
+    }
+    if (!search.startsWith('?')) {
+        throw new Error('query must start with ?');
+    }
+    const query = new node_url_1.URLSearchParams(search);
+    const f = query.get('f');
+    if (typeof f !== 'string') {
+        throw new Error('must pass `f` parameter');
+    }
+    const data = await (0, get_file_source_1.getFileSource)(remotionRoot, decodeURIComponent(f));
+    response.writeHead(200);
+    response.write(data);
+    return response.end();
+};
+const handleOpenInEditor = async (remotionRoot, req, res) => {
+    if (req.method === 'OPTIONS') {
+        res.statusCode = 200;
+        res.end();
+        return;
+    }
+    try {
+        const body = (await (0, parse_body_1.parseRequestBody)(req));
+        if (!('stack' in body)) {
+            throw new TypeError('Need to pass stack');
+        }
+        const stack = body.stack;
+        const guess = await editorGuess;
+        const didOpen = await (0, open_in_editor_1.launchEditor)({
+            colNumber: stack.originalColumnNumber,
+            editor: guess[0],
+            fileName: node_path_1.default.resolve(remotionRoot, stack.originalFileName),
+            lineNumber: stack.originalLineNumber,
+            vsCodeNewWindow: false,
+        });
+        res.setHeader('content-type', 'application/json');
+        res.writeHead(200);
+        res.end(JSON.stringify({
+            success: didOpen,
+        }));
+    }
+    catch (err) {
+        res.setHeader('content-type', 'application/json');
+        res.writeHead(200);
+        res.end(JSON.stringify({
+            success: false,
+        }));
+    }
+};
+const handleFavicon = (_, response) => {
+    const filePath = node_path_1.default.join(__dirname, '..', 'web', 'favicon.png');
+    const stat = (0, node_fs_1.statSync)(filePath);
+    response.writeHead(200, {
+        'Content-Type': 'image/png',
+        'Content-Length': stat.size,
+    });
+    const readStream = (0, node_fs_1.createReadStream)(filePath);
+    readStream.pipe(response);
+};
+const handleWasm = (_, response) => {
+    const filePath = node_path_1.default.resolve(require.resolve('source-map'), '..', 'lib', 'mappings.wasm');
+    const stat = (0, node_fs_1.statSync)(filePath);
+    response.writeHead(200, {
+        'Content-Type': 'application/wasm',
+        'Content-Length': stat.size,
+    });
+    const readStream = (0, node_fs_1.createReadStream)(filePath);
+    readStream.pipe(response);
+};
+const handleRoutes = ({ staticHash, staticHashPrefix, outputHash, outputHashPrefix, request, response, liveEventsServer, getCurrentInputProps, getEnvVariables, remotionRoot, entryPoint, publicDir, logLevel, getRenderQueue, getRenderDefaults, numberOfAudioTags, queueMethods: methods, }) => {
+    const url = new URL(request.url, 'http://localhost');
+    if (url.pathname === '/api/project-info') {
+        return handleProjectInfo(remotionRoot, request, response);
+    }
+    if (url.pathname === '/api/file-source') {
+        return handleFileSource({
+            remotionRoot,
+            search: url.search,
+            method: request.method,
+            response,
+        });
+    }
+    if (url.pathname === '/api/open-in-editor') {
+        return handleOpenInEditor(remotionRoot, request, response);
+    }
+    for (const [key, value] of Object.entries(api_routes_1.allApiRoutes)) {
+        if (url.pathname === key) {
+            return (0, handler_1.handleRequest)({
+                remotionRoot,
+                entryPoint,
+                handler: value,
+                request,
+                response,
+                logLevel,
+                methods,
+            });
+        }
+    }
+    if (url.pathname === '/remotion.png') {
+        return handleFavicon(request, response);
+    }
+    if (url.pathname === source_map_endpoint_1.SOURCE_MAP_ENDPOINT) {
+        return handleWasm(request, response);
+    }
+    if (url.pathname === '/events') {
+        return liveEventsServer.router(request, response);
+    }
+    if (url.pathname.startsWith(staticHash)) {
+        const filename = new URL(request.url, 'http://localhost').pathname.replace(new RegExp(`^${staticHash}`), '');
+        const filePath = (0, node_path_1.join)(publicDir, decodeURIComponent(filename));
+        return (0, serve_static_1.serveStatic)({
+            root: publicDir,
+            path: filePath,
+            req: request,
+            res: response,
+        });
+    }
+    if (url.pathname.startsWith(staticHashPrefix)) {
+        return static404(response);
+    }
+    if (url.pathname.startsWith(outputHash)) {
+        const filename = new URL(request.url, 'http://localhost').pathname.replace(new RegExp(`^${outputHash}`), '');
+        const filePath = (0, node_path_1.join)(remotionRoot, decodeURIComponent(filename));
+        return (0, serve_static_1.serveStatic)({
+            root: remotionRoot,
+            path: filePath,
+            req: request,
+            res: response,
+        });
+    }
+    if (url.pathname.startsWith(outputHashPrefix)) {
+        return output404(response);
+    }
+    return handleFallback({
+        remotionRoot,
+        hash: staticHash,
+        response,
+        getCurrentInputProps,
+        getEnvVariables,
+        publicDir,
+        getRenderQueue,
+        getRenderDefaults,
+        numberOfAudioTags,
+    });
+};
+exports.handleRoutes = handleRoutes;

package/dist/server-ready.d.ts

@@ -0,0 +1,2 @@
+export declare const setServerReadyComment: (newMessage: string) => void;
+export declare const printServerReadyComment: (prefix: string) => void;

package/dist/server-ready.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printServerReadyComment = exports.setServerReadyComment = void 0;
+const renderer_1 = require("@remotion/renderer");
+let message = null;
+const setServerReadyComment = (newMessage) => {
+    message = newMessage;
+};
+exports.setServerReadyComment = setServerReadyComment;
+const printServerReadyComment = (prefix) => {
+    renderer_1.RenderInternals.Log.info(`${prefix} - ${message}`);
+};
+exports.printServerReadyComment = printServerReadyComment;

package/dist/start-studio.d.ts

@@ -0,0 +1,26 @@
+import type { WebpackOverrideFn } from '@remotion/bundler';
+import type { RenderDefaults } from '@remotion/bundler/dist/index-html';
+import type { LogLevel } from '@remotion/renderer';
+import type { QueueMethods } from './preview-server/api-types';
+import type { RenderJob } from './preview-server/job';
+export declare const startStudio: ({ browserArgs, browserFlag, configValueShouldOpenBrowser, fullEntryPath, logLevel, getCurrentInputProps, getEnvVariables, desiredPort, maxTimelineTracks, remotionRoot, keyboardShortcutsEnabled, userPassedPublicDir, webpackOverride, poll, getRenderDefaults, getRenderQueue, numberOfAudioTags, queueMethods, parsedCliOpen, }: {
+    browserArgs: string;
+    browserFlag: string;
+    logLevel: LogLevel;
+    configValueShouldOpenBrowser: boolean;
+    fullEntryPath: string;
+    getCurrentInputProps: () => object;
+    getEnvVariables: () => Record<string, string>;
+    desiredPort: number | null;
+    maxTimelineTracks: number;
+    remotionRoot: string;
+    keyboardShortcutsEnabled: boolean;
+    userPassedPublicDir: string | null;
+    webpackOverride: WebpackOverrideFn;
+    poll: number | null;
+    getRenderDefaults: () => RenderDefaults;
+    getRenderQueue: () => RenderJob[];
+    numberOfAudioTags: number;
+    queueMethods: QueueMethods;
+    parsedCliOpen: boolean;
+}) => Promise<void>;

package/dist/start-studio.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startStudio = void 0;
+const renderer_1 = require("@remotion/renderer");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = require("node:fs");
+const path_1 = __importDefault(require("path"));
+const better_opn_1 = require("./better-opn");
+const get_network_address_1 = require("./get-network-address");
+const get_absolute_public_dir_1 = require("./preview-server/get-absolute-public-dir");
+const live_events_1 = require("./preview-server/live-events");
+const public_folder_1 = require("./preview-server/public-folder");
+const start_server_1 = require("./preview-server/start-server");
+const server_ready_1 = require("./server-ready");
+const watch_root_file_1 = require("./watch-root-file");
+const noop = () => undefined;
+const getShouldOpenBrowser = ({ configValueShouldOpenBrowser, parsedCliOpen, }) => {
+    var _a;
+    if (parsedCliOpen === false) {
+        return {
+            shouldOpenBrowser: false,
+            reasonForBrowserDecision: '--no-open specified',
+        };
+    }
+    if (((_a = process.env.BROWSER) !== null && _a !== void 0 ? _a : '').toLowerCase() === 'none') {
+        return {
+            shouldOpenBrowser: false,
+            reasonForBrowserDecision: 'env BROWSER=none was set',
+        };
+    }
+    if (configValueShouldOpenBrowser === false) {
+        return { shouldOpenBrowser: false, reasonForBrowserDecision: 'Config file' };
+    }
+    return { shouldOpenBrowser: true, reasonForBrowserDecision: 'default' };
+};
+const startStudio = async ({ browserArgs, browserFlag, configValueShouldOpenBrowser, fullEntryPath, logLevel, getCurrentInputProps, getEnvVariables, desiredPort, maxTimelineTracks, remotionRoot, keyboardShortcutsEnabled, userPassedPublicDir, webpackOverride, poll, getRenderDefaults, getRenderQueue, numberOfAudioTags, queueMethods, parsedCliOpen, }) => {
+    (0, watch_root_file_1.watchRootFile)(remotionRoot);
+    const publicDir = (0, get_absolute_public_dir_1.getAbsolutePublicDir)({
+        userPassedPublicDir,
+        remotionRoot,
+    });
+    const hash = node_crypto_1.default.randomBytes(6).toString('hex');
+    const outputHashPrefix = '/outputs-';
+    const outputHash = `${outputHashPrefix}${hash}`;
+    const staticHashPrefix = '/static-';
+    const staticHash = `${staticHashPrefix}${hash}`;
+    (0, public_folder_1.initPublicFolderWatch)({
+        publicDir,
+        remotionRoot,
+        onUpdate: () => {
+            (0, live_events_1.waitForLiveEventsListener)().then((listener) => {
+                const files = (0, public_folder_1.getFiles)();
+                listener.sendEventToClient({
+                    type: 'new-public-folder',
+                    files,
+                    folderExists: files.length > 0
+                        ? publicDir
+                        : (0, node_fs_1.existsSync)(publicDir)
+                            ? publicDir
+                            : null,
+                });
+            });
+        },
+        staticHash,
+    });
+    const { port, liveEventsServer } = await (0, start_server_1.startServer)({
+        entry: path_1.default.resolve(__dirname, 'previewEntry.js'),
+        userDefinedComponent: fullEntryPath,
+        getCurrentInputProps,
+        getEnvVariables,
+        port: desiredPort,
+        maxTimelineTracks,
+        remotionRoot,
+        keyboardShortcutsEnabled,
+        publicDir,
+        webpackOverride,
+        poll,
+        userPassedPublicDir,
+        staticHash,
+        staticHashPrefix,
+        outputHash,
+        outputHashPrefix,
+        logLevel,
+        getRenderDefaults,
+        getRenderQueue,
+        numberOfAudioTags,
+        queueMethods,
+    });
+    (0, live_events_1.setLiveEventsListener)(liveEventsServer);
+    const networkAddress = (0, get_network_address_1.getNetworkAddress)();
+    if (networkAddress) {
+        (0, server_ready_1.setServerReadyComment)(`Local: ${renderer_1.RenderInternals.chalk.underline(`http://localhost:${port}`)}, Network: ${renderer_1.RenderInternals.chalk.underline(`http://${networkAddress}:${port}`)}`);
+    }
+    else {
+        (0, server_ready_1.setServerReadyComment)(`http://localhost:${port}`);
+    }
+    (0, server_ready_1.printServerReadyComment)('Server ready');
+    const { reasonForBrowserDecision, shouldOpenBrowser } = getShouldOpenBrowser({
+        configValueShouldOpenBrowser,
+        parsedCliOpen,
+    });
+    if (shouldOpenBrowser) {
+        await (0, better_opn_1.openBrowser)({
+            url: `http://localhost:${port}`,
+            browserArgs,
+            browserFlag,
+        });
+    }
+    else {
+        renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `Not opening browser, reason: ${reasonForBrowserDecision}`);
+    }
+    await new Promise(noop);
+};
+exports.startStudio = startStudio;

package/dist/state/aspect-ratio-locked.d.ts

@@ -0,0 +1,2 @@
+export declare const persistAspectRatioOption: (option: boolean) => void;
+export declare const loadAspectRatioOption: () => boolean;

package/dist/state/aspect-ratio-locked.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAspectRatioOption = exports.persistAspectRatioOption = void 0;
+const aspectRatioLocalStorageKey = 'aspectRatio';
+const persistAspectRatioOption = (option) => {
+    localStorage.setItem(aspectRatioLocalStorageKey, String(option));
+};
+exports.persistAspectRatioOption = persistAspectRatioOption;
+const loadAspectRatioOption = () => {
+    const item = localStorage.getItem(aspectRatioLocalStorageKey);
+    if (item === null) {
+        return true;
+    }
+    return item !== 'false';
+};
+exports.loadAspectRatioOption = loadAspectRatioOption;

package/dist/state/canvas-ref.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const canvasRef: import("react").RefObject<HTMLDivElement>;

package/dist/state/canvas-ref.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canvasRef = void 0;
+const react_1 = require("react");
+exports.canvasRef = (0, react_1.createRef)();