@remotion/studio-server 4.0.464 → 4.0.466

package/dist/codemods/apply-codemod-to-file.d.ts

@@ -0,0 +1,6 @@
+import type { RecastCodemod, SymbolicatedStackFrame } from '@remotion/studio-shared';
+export declare const resolveFilePathFromSymbolicatedStack: (remotionRoot: string, stack: SymbolicatedStackFrame) => string;
+export declare const applyCodemodToFile: ({ filePath, codeMod, }: {
+    filePath: string;
+    codeMod: RecastCodemod;
+}) => Promise<string>;

package/dist/codemods/apply-codemod-to-file.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCodemodToFile = exports.resolveFilePathFromSymbolicatedStack = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const can_update_default_props_1 = require("../preview-server/routes/can-update-default-props");
+const duplicate_composition_1 = require("./duplicate-composition");
+const resolveFilePathFromSymbolicatedStack = (remotionRoot, stack) => {
+    if (!stack.originalFileName) {
+        throw new Error('Could not determine the file where this composition is defined');
+    }
+    const absolutePath = node_path_1.default.resolve(remotionRoot, stack.originalFileName);
+    const fileRelativeToRoot = node_path_1.default.relative(remotionRoot, absolutePath);
+    if (fileRelativeToRoot.startsWith('..')) {
+        throw new Error('Cannot apply codemod to a file outside the project');
+    }
+    if (!(0, node_fs_1.existsSync)(absolutePath)) {
+        throw new Error(`File not found: ${stack.originalFileName}`);
+    }
+    return absolutePath;
+};
+exports.resolveFilePathFromSymbolicatedStack = resolveFilePathFromSymbolicatedStack;
+const applyCodemodToFile = async ({ filePath, codeMod, }) => {
+    (0, can_update_default_props_1.checkIfTypeScriptFile)(filePath);
+    const input = (0, node_fs_1.readFileSync)(filePath, 'utf-8');
+    const { newContents } = (0, duplicate_composition_1.parseAndApplyCodemod)({
+        codeMod,
+        input,
+    });
+    return (0, duplicate_composition_1.formatOutput)(newContents);
+};
+exports.applyCodemodToFile = applyCodemodToFile;

package/dist/codemods/delete-effect.d.ts

@@ -0,0 +1,12 @@
+import type { SequenceNodePath } from 'remotion';
+export declare const deleteEffect: ({ input, sequenceNodePath, effectIndex, prettierConfigOverride, }: {
+    input: string;
+    sequenceNodePath: SequenceNodePath;
+    effectIndex: number;
+    prettierConfigOverride?: Record<string, unknown> | null | undefined;
+}) => Promise<{
+    output: string;
+    formatted: boolean;
+    effectLabel: string;
+    logLine: number;
+}>;

package/dist/codemods/delete-effect.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteEffect = void 0;
+const can_update_sequence_props_1 = require("../preview-server/routes/can-update-sequence-props");
+const format_file_content_1 = require("./format-file-content");
+const parse_ast_1 = require("./parse-ast");
+const update_effect_props_1 = require("./update-effect-props/update-effect-props");
+const getEffectsArray = (attr) => {
+    if (!attr.value || attr.value.type !== 'JSXExpressionContainer') {
+        throw new Error('Cannot delete effect: effects prop is not an array');
+    }
+    const expr = attr.value.expression;
+    if (expr.type !== 'ArrayExpression') {
+        throw new Error('Cannot delete effect: effects prop is not an array');
+    }
+    return expr;
+};
+const deleteEffect = async ({ input, sequenceNodePath, effectIndex, prettierConfigOverride, }) => {
+    var _a, _b;
+    var _c, _d, _e;
+    const ast = (0, parse_ast_1.parseAst)(input);
+    const jsx = (0, can_update_sequence_props_1.findJsxElementAtNodePath)(ast, sequenceNodePath);
+    if (!jsx) {
+        throw new Error('Could not find a JSX element at the specified location to delete effect');
+    }
+    const attr = (0, update_effect_props_1.findEffectsAttr)((_c = jsx.attributes) !== null && _c !== void 0 ? _c : []);
+    if (!attr) {
+        throw new Error('Could not find effects on the target JSX element');
+    }
+    const effectsArray = getEffectsArray(attr);
+    const found = (0, update_effect_props_1.findEffectCallExpression)({ attr, effectIndex });
+    if (found.kind === 'error') {
+        throw new Error(`Cannot delete effect: ${found.reason}`);
+    }
+    effectsArray.elements.splice(effectIndex, 1);
+    if (effectsArray.elements.length === 0) {
+        const attrIndex = jsx.attributes.indexOf(attr);
+        if (attrIndex !== -1) {
+            jsx.attributes.splice(attrIndex, 1);
+        }
+    }
+    const finalFile = (0, parse_ast_1.serializeAst)(ast);
+    const { output, formatted } = await (0, format_file_content_1.formatFileContent)({
+        input: finalFile,
+        prettierConfigOverride,
+    });
+    return {
+        output,
+        formatted,
+        effectLabel: `${found.callee}()`,
+        logLine: (_e = (_d = (_a = found.call.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _d !== void 0 ? _d : (_b = jsx.loc) === null || _b === void 0 ? void 0 : _b.start.line) !== null && _e !== void 0 ? _e : 1,
+    };
+};
+exports.deleteEffect = deleteEffect;

package/dist/codemods/duplicate-composition.js

@@ -69,7 +69,7 @@ const parseAndApplyCodemod = ({ input, codeMod, }) => {
         codeMod,
     });
     if (changesMade.length === 0) {
-        throw new Error('Unable to calculate the changes needed for this file. Edit the root file manually.');
+        throw new Error('Unable to calculate the changes needed for this file. Edit the file manually.');
     }
     const output = (0, parse_ast_1.serializeAst)(newAst);
     return { changesMade, newContents: output };

package/dist/codemods/recast-mods.js

@@ -60,11 +60,65 @@ const mapReturnStatement = (statement, transformation, changesMade) => {
     if (!statement.argument) {
         return statement;
     }
+    const replacement = transformLoneJsxElement(statement.argument, transformation, changesMade);
+    if (replacement !== null) {
+        return { ...statement, argument: replacement };
+    }
     return {
         ...statement,
         argument: mapAll(statement.argument, transformation, changesMade),
     };
 };
+const nullLiteral = () => ({ type: 'NullLiteral' });
+// When a node was originally parenthesized (e.g. the `<JSX/>` inside
+// `return (<JSX/>)`), Babel records `extra.parenthesized` on it. If we move
+// such a node into a JSXFragment without clearing that hint, recast prints
+// stray `(` / `)` characters around it as JSX text. Clear the hint so the
+// node prints cleanly in its new context.
+const stripParenthesizedExtra = (node) => {
+    if (!node.extra) {
+        return node;
+    }
+    const { parenthesized: _p, parenStart: _ps, ...rest } = node.extra;
+    return { ...node, extra: rest };
+};
+const wrapInJsxFragment = (children) => ({
+    type: 'JSXFragment',
+    openingFragment: { type: 'JSXOpeningFragment' },
+    closingFragment: { type: 'JSXClosingFragment' },
+    children: children.map(stripParenthesizedExtra),
+});
+// When a <Composition> JSX element appears in a position where it cannot
+// simply be removed from a parent's children list (e.g. as the sole return
+// value of a wrapper component or as the concise body of an arrow function),
+// we still want delete/rename/duplicate codemods to work. This helper detects
+// that case and produces a structurally-valid replacement expression.
+const transformLoneJsxElement = (expression, transformation, changesMade) => {
+    if (expression.type !== 'JSXElement') {
+        return null;
+    }
+    const compId = getCompositionIdFromJSXElement(expression);
+    if (compId === null) {
+        return null;
+    }
+    const isMatch = (transformation.type === 'delete-composition' &&
+        compId === transformation.idToDelete) ||
+        (transformation.type === 'rename-composition' &&
+            compId === transformation.idToRename) ||
+        (transformation.type === 'duplicate-composition' &&
+            compId === transformation.idToDuplicate);
+    if (!isMatch) {
+        return null;
+    }
+    const transformed = mapJsxChild(expression, transformation, changesMade);
+    if (transformed.length === 0) {
+        return nullLiteral();
+    }
+    if (transformed.length === 1) {
+        return transformed[0];
+    }
+    return wrapInJsxFragment(transformed);
+};
 const mapJsxElementOrFragment = (jsxFragment, transformation, changesMade) => {
     return {
         ...jsxFragment,
@@ -129,6 +183,16 @@ const mapRecognizedType = (expression, transformation, changesMade) => {
     }
     if (expression.type === 'ArrowFunctionExpression' ||
         expression.type === 'FunctionExpression') {
+        if (expression.type === 'ArrowFunctionExpression' &&
+            expression.body.type === 'JSXElement') {
+            const replacement = transformLoneJsxElement(expression.body, transformation, changesMade);
+            if (replacement !== null) {
+                return {
+                    ...expression,
+                    body: replacement,
+                };
+            }
+        }
         return {
             ...expression,
             body: mapAll(expression.body, transformation, changesMade),

package/dist/codemods/update-effect-props/update-effect-props.d.ts

@@ -12,6 +12,7 @@ export type UpdateEffectPropsResult = {
     logLine: number;
     effectCallee: string;
 };
+export declare const findEffectsAttr: (attrs: readonly unknown[]) => JSXAttribute | null;
 export type EffectArrayElement = {
     kind: 'call';
     callee: string;

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

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateEffectProps = exports.updateEffectPropsAst = exports.findEffectCallExpression = exports.enumerateEffectArrayElements = void 0;
+exports.updateEffectProps = exports.updateEffectPropsAst = exports.findEffectCallExpression = exports.enumerateEffectArrayElements = exports.findEffectsAttr = void 0;
 const studio_shared_1 = require("@remotion/studio-shared");
 const recast = __importStar(require("recast"));
 const can_update_sequence_props_1 = require("../../preview-server/routes/can-update-sequence-props");
@@ -50,19 +50,19 @@ const parseValueExpression = (value) => {
     }
     return stmt.expression.right;
 };
-const findExperimentalEffectsAttr = (attrs) => {
+const findEffectsAttr = (attrs) => {
     for (const attr of attrs) {
         if (attr.type !== 'JSXAttribute') {
             continue;
         }
         const a = attr;
-        if (a.name.type === 'JSXIdentifier' &&
-            a.name.name === '_experimentalEffects') {
+        if (a.name.type === 'JSXIdentifier' && a.name.name === 'effects') {
             return a;
         }
     }
     return null;
 };
+exports.findEffectsAttr = findEffectsAttr;
 const getCalleeName = (call) => {
     const { callee } = call;
     if (callee.type === 'Identifier') {
@@ -140,9 +140,9 @@ const updateEffectPropsAst = ({ input, sequenceNodePath, effectIndex, update, })
     if (!jsx) {
         throw new Error('Could not find a JSX element at the specified location to update effects');
     }
-    const attr = findExperimentalEffectsAttr((_e = jsx.attributes) !== null && _e !== void 0 ? _e : []);
+    const attr = (0, exports.findEffectsAttr)((_e = jsx.attributes) !== null && _e !== void 0 ? _e : []);
     if (!attr) {
-        throw new Error('Could not find _experimentalEffects on the target JSX element');
+        throw new Error('Could not find effects on the target JSX element');
     }
     const found = (0, exports.findEffectCallExpression)({
         attr,

package/dist/helpers/resolve-composition-component.d.ts

@@ -0,0 +1,11 @@
+export type ResolvedCompositionComponent = {
+    source: string;
+    line: number;
+    column: number;
+    canAddSequence: boolean;
+};
+export declare const resolveCompositionComponent: ({ remotionRoot, compositionFile, compositionId, }: {
+    remotionRoot: string;
+    compositionFile: string;
+    compositionId: string;
+}) => Promise<ResolvedCompositionComponent>;