@remotion/studio-server 4.0.134 → 4.0.136

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
 
-> @remotion/studio-server@4.0.134 build /Users/jonathanburger/remotion/packages/studio-server
+> @remotion/studio-server@4.0.135 build /Users/jonathanburger/remotion/packages/studio-server
 > tsc -d
 

package/dist/codemods/duplicate-composition.d.ts

@@ -0,0 +1,10 @@
+import type { RecastCodemod } from '@remotion/studio-shared';
+import type { Change } from './recast-mods';
+export declare const formatOutput: (tsContent: string) => Promise<string>;
+export declare const parseAndApplyCodemod: ({ input, codeMod, }: {
+    input: string;
+    codeMod: RecastCodemod;
+}) => {
+    newContents: string;
+    changesMade: Change[];
+};

package/dist/codemods/duplicate-composition.js

@@ -0,0 +1,72 @@
+"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.parseAndApplyCodemod = exports.formatOutput = void 0;
+const recast = __importStar(require("recast"));
+const tsParser = __importStar(require("recast/parsers/babel-ts"));
+const recast_mods_1 = require("./recast-mods");
+const getPrettier = async () => {
+    try {
+        return await Promise.resolve().then(() => __importStar(require('prettier')));
+    }
+    catch (err) {
+        throw new Error('Prettier cannot be found in the current project.');
+    }
+};
+const formatOutput = async (tsContent) => {
+    const prettier = await getPrettier();
+    const { format, resolveConfig, resolveConfigFile } = prettier;
+    const configFilePath = await resolveConfigFile();
+    if (!configFilePath) {
+        throw new Error('The Prettier config file was not found');
+    }
+    const prettierConfig = await resolveConfig(configFilePath);
+    if (!prettierConfig) {
+        throw new Error(`The Prettier config at ${configFilePath} could not be read`);
+    }
+    const newContents = await format(tsContent, {
+        ...prettierConfig,
+        filepath: 'test.tsx',
+    });
+    return newContents;
+};
+exports.formatOutput = formatOutput;
+const parseAndApplyCodemod = ({ input, codeMod, }) => {
+    const ast = recast.parse(input, {
+        parser: tsParser,
+    });
+    const { newAst, changesMade } = (0, recast_mods_1.applyCodemod)({
+        file: ast,
+        codeMod,
+    });
+    if (changesMade.length === 0) {
+        throw new Error('Unable to calculate the changes needed for this file. Edit the root file manually.');
+    }
+    const output = recast.print(newAst, {
+        parser: tsParser,
+    }).code;
+    return { changesMade, newContents: output };
+};
+exports.parseAndApplyCodemod = parseAndApplyCodemod;

package/dist/codemods/recast-mods.d.ts

@@ -0,0 +1,12 @@
+import type { File } from '@babel/types';
+import type { RecastCodemod } from '@remotion/studio-shared';
+export type Change = {
+    description: string;
+};
+export declare const applyCodemod: ({ file, codeMod, }: {
+    file: File;
+    codeMod: RecastCodemod;
+}) => {
+    newAst: File;
+    changesMade: Change[];
+};

package/dist/codemods/recast-mods.js

@@ -0,0 +1,354 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCodemod = void 0;
+const applyCodemod = ({ file, codeMod, }) => {
+    const changesMade = [];
+    const body = file.program.body.map((node) => {
+        return mapAll(node, codeMod, changesMade);
+    });
+    return {
+        newAst: {
+            ...file,
+            program: {
+                ...file.program,
+                body,
+            },
+        },
+        changesMade,
+    };
+};
+exports.applyCodemod = applyCodemod;
+const mapAll = (node, transformation, changesMade) => {
+    if (isRecognizedType(node)) {
+        return mapRecognizedType(node, transformation, changesMade);
+    }
+    return node;
+};
+const isRecognizedType = (t) => {
+    return (t.type === 'ArrowFunctionExpression' ||
+        t.type === 'FunctionExpression' ||
+        t.type === 'JSXFragment' ||
+        t.type === 'JSXElement' ||
+        t.type === 'BlockStatement' ||
+        t.type === 'ReturnStatement' ||
+        t.type === 'VariableDeclaration' ||
+        t.type === 'FunctionDeclaration' ||
+        t.type === 'ExportNamedDeclaration' ||
+        t.type === 'ExportDefaultDeclaration');
+};
+const mapVariableDeclarator = (variableDeclarator, transformation, changesMade) => {
+    return {
+        ...variableDeclarator,
+        init: variableDeclarator.init
+            ? mapAll(variableDeclarator.init, transformation, changesMade)
+            : variableDeclarator.init,
+    };
+};
+const mapBlockStatement = (blockStatement, transformation, changesMade) => {
+    return {
+        ...blockStatement,
+        body: blockStatement.body.map((a) => {
+            return mapAll(a, transformation, changesMade);
+        }),
+    };
+};
+const mapReturnStatement = (statement, transformation, changesMade) => {
+    if (!statement.argument) {
+        return statement;
+    }
+    return {
+        ...statement,
+        argument: mapAll(statement.argument, transformation, changesMade),
+    };
+};
+const mapJsxElementOrFragment = (jsxFragment, transformation, changesMade) => {
+    return {
+        ...jsxFragment,
+        children: jsxFragment.children
+            .map((c) => {
+            if (c.type !== 'JSXElement') {
+                return c;
+            }
+            return mapJsxChild(c, transformation, changesMade);
+        })
+            .flat(1),
+    };
+};
+const mapJsxChild = (c, transformation, changesMade) => {
+    const compId = getCompositionIdFromJSXElement(c);
+    if (transformation === null) {
+        return [c];
+    }
+    if (transformation.type === 'duplicate-composition' &&
+        compId === transformation.idToDuplicate) {
+        return [
+            c,
+            changeComposition({
+                jsxElement: c,
+                newCompositionId: transformation.newId,
+                newCompositionFps: transformation.newFps,
+                newCompositionDurationInFrames: transformation.newDurationInFrames,
+                newCompositionHeight: transformation.newHeight,
+                newCompositionWidth: transformation.newWidth,
+                newTagToUse: transformation.tag,
+                changesMade,
+            }),
+        ];
+    }
+    if (transformation.type === 'rename-composition' &&
+        compId === transformation.idToRename) {
+        return [
+            changeComposition({
+                jsxElement: c,
+                newCompositionId: transformation.newId,
+                newCompositionFps: null,
+                newCompositionDurationInFrames: null,
+                newCompositionHeight: null,
+                newCompositionWidth: null,
+                changesMade,
+                newTagToUse: null,
+            }),
+        ];
+    }
+    if (transformation.type === 'delete-composition' &&
+        compId === transformation.idToDelete) {
+        changesMade.push({
+            description: 'Deleted composition',
+        });
+        return [];
+    }
+    return [mapAll(c, transformation, changesMade)];
+};
+const mapRecognizedType = (expression, transformation, changesMade) => {
+    if (expression.type === 'JSXFragment' || expression.type === 'JSXElement') {
+        return mapJsxElementOrFragment(expression, transformation, changesMade);
+    }
+    if (expression.type === 'ArrowFunctionExpression' ||
+        expression.type === 'FunctionExpression') {
+        return {
+            ...expression,
+            body: mapAll(expression.body, transformation, changesMade),
+        };
+    }
+    if (expression.type === 'VariableDeclaration') {
+        const declarations = expression.declarations.map((d) => {
+            return mapVariableDeclarator(d, transformation, changesMade);
+        });
+        return { ...expression, declarations };
+    }
+    if (expression.type === 'FunctionDeclaration') {
+        return {
+            ...expression,
+            body: mapBlockStatement(expression.body, transformation, changesMade),
+        };
+    }
+    if (expression.type === 'ExportNamedDeclaration' ||
+        expression.type === 'ExportDefaultDeclaration') {
+        if (!expression.declaration) {
+            return expression;
+        }
+        return {
+            ...expression,
+            declaration: mapAll(expression.declaration, transformation, changesMade),
+        };
+    }
+    if (expression.type === 'ReturnStatement') {
+        return mapReturnStatement(expression, transformation, changesMade);
+    }
+    if (expression.type === 'BlockStatement') {
+        return mapBlockStatement(expression, transformation, changesMade);
+    }
+    return expression;
+};
+const getCompositionIdFromJSXElement = (jsxElement) => {
+    if (jsxElement.type !== 'JSXElement') {
+        return null;
+    }
+    const { openingElement } = jsxElement;
+    const { name } = openingElement;
+    if (name.type !== 'JSXIdentifier') {
+        return null;
+    }
+    if (name.name !== 'Composition' && name.name !== 'Still') {
+        return null;
+    }
+    const id = openingElement.attributes
+        .map((attribute) => {
+        if (attribute.type === 'JSXSpreadAttribute') {
+            return null;
+        }
+        if (attribute.name.type === 'JSXNamespacedName') {
+            return null;
+        }
+        if (attribute.name.name !== 'id') {
+            return null;
+        }
+        if (!attribute.value) {
+            return null;
+        }
+        if (attribute.value.type === 'StringLiteral') {
+            return attribute.value.value;
+        }
+        if (attribute.value.type === 'JSXExpressionContainer' &&
+            attribute.value.expression.type === 'StringLiteral') {
+            return attribute.value.expression.value;
+        }
+        return null;
+    })
+        .filter(Boolean);
+    return id[0];
+};
+const changeComposition = ({ jsxElement, newCompositionId, newCompositionFps, newCompositionDurationInFrames, newCompositionHeight, newCompositionWidth, changesMade, newTagToUse, }) => {
+    const { openingElement } = jsxElement;
+    const { name } = openingElement;
+    if (name.type !== 'JSXIdentifier') {
+        return jsxElement;
+    }
+    if (name.name !== 'Composition' && name.name !== 'Still') {
+        return jsxElement;
+    }
+    const attributes = openingElement.attributes
+        .map((attribute) => {
+        if (attribute.type === 'JSXSpreadAttribute') {
+            return attribute;
+        }
+        if (attribute.name.type === 'JSXNamespacedName') {
+            return attribute;
+        }
+        if (attribute.name.name === 'fps' && newTagToUse === 'Still') {
+            changesMade.push({ description: 'Removed fps attribute' });
+            return null;
+        }
+        if (attribute.name.name === 'durationInFrames' &&
+            newTagToUse === 'Still') {
+            changesMade.push({ description: 'Removed durationInFrames' });
+            return null;
+        }
+        // id="one"
+        if (attribute.name.name === 'id' &&
+            attribute.value &&
+            attribute.value.type === 'StringLiteral') {
+            changesMade.push({
+                description: 'Replaced composition id',
+            });
+            return {
+                ...attribute,
+                value: { ...attribute.value, value: newCompositionId },
+            };
+        }
+        // id={"one"}
+        if (attribute.name.name === 'id' &&
+            attribute.value &&
+            attribute.value.type === 'JSXExpressionContainer' &&
+            attribute.value.expression.type === 'StringLiteral') {
+            changesMade.push({
+                description: 'Replaced composition id',
+            });
+            return {
+                ...attribute,
+                value: {
+                    ...attribute.value,
+                    expression: {
+                        ...attribute.value.expression,
+                        value: newCompositionId,
+                    },
+                },
+            };
+        }
+        if (attribute.name.name === 'fps' &&
+            attribute.value &&
+            attribute.value.type === 'JSXExpressionContainer' &&
+            attribute.value.expression.type === 'NumericLiteral' &&
+            newCompositionFps !== null) {
+            changesMade.push({
+                description: 'Replaced FPS',
+            });
+            return {
+                ...attribute,
+                value: {
+                    ...attribute.value,
+                    expression: {
+                        ...attribute.value.expression,
+                        value: newCompositionFps,
+                    },
+                },
+            };
+        }
+        if (attribute.name.name === 'durationInFrames' &&
+            attribute.value &&
+            attribute.value.type === 'JSXExpressionContainer' &&
+            attribute.value.expression.type === 'NumericLiteral' &&
+            newCompositionDurationInFrames !== null) {
+            changesMade.push({
+                description: 'Replaced durationInFrames',
+            });
+            return {
+                ...attribute,
+                value: {
+                    ...attribute.value,
+                    expression: {
+                        ...attribute.value.expression,
+                        value: newCompositionDurationInFrames,
+                    },
+                },
+            };
+        }
+        if (attribute.name.name === 'width' &&
+            attribute.value &&
+            attribute.value.type === 'JSXExpressionContainer' &&
+            attribute.value.expression.type === 'NumericLiteral' &&
+            newCompositionWidth !== null) {
+            changesMade.push({
+                description: 'Replaced width',
+            });
+            return {
+                ...attribute,
+                value: {
+                    ...attribute.value,
+                    expression: {
+                        ...attribute.value.expression,
+                        value: newCompositionWidth,
+                    },
+                },
+            };
+        }
+        if (attribute.name.name === 'height' &&
+            attribute.value &&
+            attribute.value.type === 'JSXExpressionContainer' &&
+            attribute.value.expression.type === 'NumericLiteral' &&
+            newCompositionHeight !== null) {
+            changesMade.push({
+                description: 'Replaced height',
+            });
+            return {
+                ...attribute,
+                value: {
+                    ...attribute.value,
+                    expression: {
+                        ...attribute.value.expression,
+                        value: newCompositionHeight,
+                    },
+                },
+            };
+        }
+        return attribute;
+    })
+        .filter(Boolean);
+    const newName = newTagToUse !== null && newTagToUse !== void 0 ? newTagToUse : name.name;
+    if (newName !== name.name) {
+        changesMade.push({
+            description: `Changed tag`,
+        });
+    }
+    return {
+        ...jsxElement,
+        openingElement: {
+            ...jsxElement.openingElement,
+            name: {
+                ...name,
+                name: newName,
+            },
+            attributes,
+        },
+    };
+};

package/dist/codemods/simple-diff.d.ts

@@ -0,0 +1,5 @@
+import type { SimpleDiff } from '@remotion/studio-shared';
+export declare const simpleDiff: ({ oldLines, newLines, }: {
+    oldLines: string[];
+    newLines: string[];
+}) => SimpleDiff;

package/dist/codemods/simple-diff.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleDiff = void 0;
+const findDeletions = ({ oldLines, newLines, }) => {
+    const linesChecked = [];
+    let totalDeletions = 0;
+    for (const line of oldLines) {
+        if (linesChecked.includes(line)) {
+            continue;
+        }
+        const timesInNewLines = newLines.filter((l) => l === line).length;
+        const timesInOldLines = oldLines.filter((l) => l === line).length;
+        const deletions = Math.max(0, timesInOldLines - timesInNewLines);
+        totalDeletions += deletions;
+        linesChecked.push(line);
+    }
+    return totalDeletions;
+};
+const findAdditions = ({ oldLines, newLines, }) => {
+    const linesChecked = [];
+    let totalAdditions = 0;
+    for (const line of newLines) {
+        if (linesChecked.includes(line)) {
+            continue;
+        }
+        const timesInNewLines = newLines.filter((l) => l === line).length;
+        const timesInOldLines = oldLines.filter((l) => l === line).length;
+        const additions = Math.max(0, timesInNewLines - timesInOldLines);
+        totalAdditions += additions;
+        linesChecked.push(line);
+    }
+    return totalAdditions;
+};
+const simpleDiff = ({ oldLines, newLines, }) => {
+    const deletions = findDeletions({ oldLines, newLines });
+    const additions = findAdditions({ oldLines, newLines });
+    return { deletions, additions };
+};
+exports.simpleDiff = simpleDiff;

package/dist/codemods/update-default-props.js

@@ -124,7 +124,7 @@ const updateDefaultProps = async ({ input, compositionId, newDefaultProps, enumP
     if (!prettierConfig) {
         throw new Error(`The Prettier config at ${configFilePath} could not be read`);
     }
-    const prettified = format(newFile, {
+    const prettified = await format(newFile, {
         ...prettierConfig,
         rangeStart: startPos,
         rangeEnd: endPos,

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export declare const StudioServerInternals: {
     startStudio: ({ browserArgs, browserFlag, configValueShouldOpenBrowser, fullEntryPath, logLevel, getCurrentInputProps, getEnvVariables, desiredPort, maxTimelineTracks, remotionRoot, keyboardShortcutsEnabled, relativePublicDir, webpackOverride, poll, getRenderDefaults, getRenderQueue, numberOfAudioTags, queueMethods, parsedCliOpen, previewEntry, gitSource, bufferStateDelayInMilliseconds, binariesDirectory, forceIPv4, }: {
         browserArgs: string;
         browserFlag: string;
-        logLevel: "error" | "verbose" | "info" | "warn";
+        logLevel: "verbose" | "info" | "warn" | "error";
         configValueShouldOpenBrowser: boolean;
         fullEntryPath: string;
         getCurrentInputProps: () => object;
@@ -59,4 +59,11 @@ export declare const StudioServerInternals: {
         binary?: boolean | undefined;
         signed: boolean;
     }) | undefined) => string;
+    parseAndApplyCodemod: ({ input, codeMod, }: {
+        input: string;
+        codeMod: import("@remotion/studio-shared").RecastCodemod;
+    }) => {
+        newContents: string;
+        changesMade: import("./codemods/recast-mods").Change[];
+    };
 };

package/dist/index.js

@@ -5,6 +5,7 @@ const studio_shared_1 = require("@remotion/studio-shared");
 var studio_shared_2 = require("@remotion/studio-shared");
 Object.defineProperty(exports, "getDefaultOutLocation", { enumerable: true, get: function () { return studio_shared_2.getDefaultOutLocation; } });
 const ansi_diff_1 = require("./ansi-diff");
+const duplicate_composition_1 = require("./codemods/duplicate-composition");
 const file_watcher_1 = require("./file-watcher");
 const get_latest_remotion_version_1 = require("./get-latest-remotion-version");
 const max_timeline_tracks_1 = require("./max-timeline-tracks");
@@ -24,4 +25,5 @@ exports.StudioServerInternals = {
     installFileWatcher: file_watcher_1.installFileWatcher,
     AnsiDiff: ansi_diff_1.AnsiDiff,
     formatBytes: studio_shared_1.formatBytes,
+    parseAndApplyCodemod: duplicate_composition_1.parseAndApplyCodemod,
 };

package/dist/preview-server/api-routes.js

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.allApiRoutes = void 0;
 const add_render_1 = require("./routes/add-render");
+const apply_codemod_1 = require("./routes/apply-codemod");
 const can_update_default_props_1 = require("./routes/can-update-default-props");
 const cancel_render_1 = require("./routes/cancel-render");
 const copy_still_to_clipboard_handler_1 = require("./routes/copy-still-to-clipboard-handler");
 const open_in_file_explorer_1 = require("./routes/open-in-file-explorer");
+const project_info_1 = require("./routes/project-info");
 const remove_render_1 = require("./routes/remove-render");
 const subscribe_to_file_existence_1 = require("./routes/subscribe-to-file-existence");
 const unsubscribe_from_file_existence_1 = require("./routes/unsubscribe-from-file-existence");
@@ -20,6 +22,8 @@ exports.allApiRoutes = {
     '/api/open-in-file-explorer': open_in_file_explorer_1.handleOpenInFileExplorer,
     '/api/copy-still-to-clipboard': copy_still_to_clipboard_handler_1.handleCopyStillToClipboard,
     '/api/update-default-props': update_default_props_1.updateDefaultPropsHandler,
+    '/api/apply-codemod': apply_codemod_1.applyCodemodHandler,
     '/api/can-update-default-props': can_update_default_props_1.canUpdateDefaultPropsHandler,
     '/api/update-available': update_available_1.handleUpdate,
+    '/api/project-info': project_info_1.projectInfoHandler,
 };

package/dist/preview-server/dev-middleware/range-parser.d.ts

@@ -11,5 +11,5 @@ type Range = {
 type Ranges = Range[] & {
     type?: string;
 };
-export declare function parseRange(size: number, str: string | string[]): -1 | Ranges | -2;
+export declare function parseRange(size: number, str: string | string[]): -2 | -1 | Ranges;
 export {};

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

@@ -21,12 +21,10 @@ const getProjectInfo = (remotionRoot) => {
     ].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;
+    const rootFile = (_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,
+        rootFile,
+        relativeRootFile: rootFile ? node_path_1.default.relative(remotionRoot, rootFile) : null,
     });
 };
 exports.getProjectInfo = getProjectInfo;

package/dist/preview-server/routes/apply-codemod.d.ts

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

package/dist/preview-server/routes/apply-codemod.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCodemodHandler = void 0;
+const renderer_1 = require("@remotion/renderer");
+const node_fs_1 = require("node:fs");
+const duplicate_composition_1 = require("../../codemods/duplicate-composition");
+const simple_diff_1 = require("../../codemods/simple-diff");
+const project_info_1 = require("../project-info");
+const can_update_default_props_1 = require("./can-update-default-props");
+const applyCodemodHandler = async ({ input: { codemod, dryRun }, logLevel, remotionRoot }) => {
+    try {
+        const time = Date.now();
+        const projectInfo = await (0, project_info_1.getProjectInfo)(remotionRoot);
+        if (!projectInfo.rootFile) {
+            throw new Error('Cannot find root file in project');
+        }
+        (0, can_update_default_props_1.checkIfTypeScriptFile)(projectInfo.rootFile);
+        const input = (0, node_fs_1.readFileSync)(projectInfo.rootFile, 'utf-8');
+        const { newContents } = (0, duplicate_composition_1.parseAndApplyCodemod)({
+            codeMod: codemod,
+            input,
+        });
+        const formatted = await (0, duplicate_composition_1.formatOutput)(newContents);
+        const diff = (0, simple_diff_1.simpleDiff)({
+            oldLines: input.split('\n'),
+            newLines: formatted.split('\n'),
+        });
+        if (!dryRun) {
+            (0, node_fs_1.writeFileSync)(projectInfo.rootFile, formatted);
+            const end = Date.now() - time;
+            renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, renderer_1.RenderInternals.chalk.blue(`Edited root file in ${end}ms`));
+        }
+        return {
+            success: true,
+            diff,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            reason: err.message,
+            stack: err.stack,
+        };
+    }
+};
+exports.applyCodemodHandler = applyCodemodHandler;

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

@@ -9,20 +9,20 @@ const checkIfTypeScriptFile = (file) => {
         !file.endsWith('.ts') &&
         !file.endsWith('.mtsx') &&
         !file.endsWith('.mts')) {
-        throw new Error('Cannot update default props for non-TypeScript files');
+        throw new Error('Cannot update Root file if not using TypeScript');
     }
 };
 exports.checkIfTypeScriptFile = checkIfTypeScriptFile;
 const canUpdateDefaultPropsHandler = async ({ input: { compositionId }, remotionRoot }) => {
     try {
         const projectInfo = await (0, project_info_1.getProjectInfo)(remotionRoot);
-        if (!projectInfo.videoFile) {
+        if (!projectInfo.rootFile) {
             throw new Error('Cannot find root file in project');
         }
-        (0, exports.checkIfTypeScriptFile)(projectInfo.videoFile);
+        (0, exports.checkIfTypeScriptFile)(projectInfo.rootFile);
         await (0, update_default_props_1.updateDefaultProps)({
             compositionId,
-            input: (0, node_fs_1.readFileSync)(projectInfo.videoFile, 'utf-8'),
+            input: (0, node_fs_1.readFileSync)(projectInfo.rootFile, 'utf-8'),
             newDefaultProps: {},
             enumPaths: [],
         });