@remotion/studio-server 4.0.472 → 4.0.473

package/dist/codemods/effect-param-expression.d.ts

@@ -0,0 +1,15 @@
+import type { File } from '@babel/types';
+import type { EffectClipboardParam, EffectClipboardSnapshot } from '@remotion/studio-shared';
+import type { ExpressionKind } from 'ast-types/lib/gen/kinds';
+export type RemotionImportName = 'Easing' | 'interpolate' | 'interpolateColors' | 'useCurrentFrame';
+export type RemotionLocalNames = Partial<Record<RemotionImportName, string>>;
+export declare const getRequiredRemotionImportsForEffectParams: (params: Iterable<EffectClipboardParam>) => Set<RemotionImportName>;
+export declare const getRequiredRemotionImports: (effects: EffectClipboardSnapshot[]) => Set<RemotionImportName>;
+export declare const ensureRemotionImportLocalNames: ({ ast, requiredImports, }: {
+    ast: File;
+    requiredImports: Set<RemotionImportName>;
+}) => Partial<Record<RemotionImportName, string>>;
+export declare const makeParamExpression: ({ param, remotionLocalNames, }: {
+    param: EffectClipboardParam;
+    remotionLocalNames: Partial<Record<RemotionImportName, string>>;
+}) => ExpressionKind;

package/dist/codemods/effect-param-expression.js

@@ -0,0 +1,131 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeParamExpression = exports.ensureRemotionImportLocalNames = exports.getRequiredRemotionImports = exports.getRequiredRemotionImportsForEffectParams = void 0;
+const recast = __importStar(require("recast"));
+const imports_1 = require("../helpers/imports");
+const update_nested_prop_1 = require("./update-nested-prop");
+const b = recast.types.builders;
+const isNonLinearEasing = (easing) => easing !== 'linear';
+const keyframedParamNeedsEasingImport = (param) => {
+    return (param.interpolationFunction !== 'interpolateColors' &&
+        param.easing.some(isNonLinearEasing));
+};
+const getRequiredRemotionImportsForEffectParams = (params) => {
+    const requiredImports = new Set();
+    for (const param of params) {
+        if (param.type !== 'keyframed') {
+            continue;
+        }
+        requiredImports.add('useCurrentFrame');
+        requiredImports.add(param.interpolationFunction);
+        if (keyframedParamNeedsEasingImport(param)) {
+            requiredImports.add('Easing');
+        }
+    }
+    return requiredImports;
+};
+exports.getRequiredRemotionImportsForEffectParams = getRequiredRemotionImportsForEffectParams;
+const getRequiredRemotionImports = (effects) => {
+    return (0, exports.getRequiredRemotionImportsForEffectParams)(effects.flatMap((effect) => Object.values(effect.params)));
+};
+exports.getRequiredRemotionImports = getRequiredRemotionImports;
+const ensureRemotionImportLocalNames = ({ ast, requiredImports, }) => {
+    const localNames = {};
+    for (const importedName of requiredImports) {
+        localNames[importedName] = (0, imports_1.ensureNamedImport)({
+            ast,
+            importedName,
+            sourcePath: 'remotion',
+            localName: importedName,
+        });
+    }
+    return localNames;
+};
+exports.ensureRemotionImportLocalNames = ensureRemotionImportLocalNames;
+const makeEasingExpression = ({ easing, easingLocalName, }) => {
+    if (easing === 'linear') {
+        return b.memberExpression(b.identifier(easingLocalName), b.identifier('linear'));
+    }
+    return b.callExpression(b.memberExpression(b.identifier(easingLocalName), b.identifier('bezier')), easing.map((value) => (0, update_nested_prop_1.parseValueExpression)(value)));
+};
+const makeKeyframedOptions = ({ param, remotionLocalNames, }) => {
+    var _a;
+    const properties = [];
+    if (param.interpolationFunction !== 'interpolateColors') {
+        if (param.clamping.left !== 'extend') {
+            properties.push(b.objectProperty(b.identifier('extrapolateLeft'), b.stringLiteral(param.clamping.left)));
+        }
+        if (param.clamping.right !== 'extend') {
+            properties.push(b.objectProperty(b.identifier('extrapolateRight'), b.stringLiteral(param.clamping.right)));
+        }
+        if (keyframedParamNeedsEasingImport(param)) {
+            const easingLocalName = (_a = remotionLocalNames.Easing) !== null && _a !== void 0 ? _a : 'Easing';
+            properties.push(b.objectProperty(b.identifier('easing'), b.arrayExpression(param.easing.map((easing) => makeEasingExpression({ easing, easingLocalName })))));
+        }
+    }
+    if (param.posterize !== undefined) {
+        properties.push(b.objectProperty(b.identifier('posterize'), (0, update_nested_prop_1.parseValueExpression)(param.posterize)));
+    }
+    if (properties.length === 0) {
+        return null;
+    }
+    return b.objectExpression(properties);
+};
+const makeKeyframedExpression = ({ param, remotionLocalNames, }) => {
+    var _a;
+    const expectedEasingCount = Math.max(0, param.keyframes.length - 1);
+    if (param.easing.length !== expectedEasingCount) {
+        throw new Error('Cannot paste keyframed effect: invalid easing metadata');
+    }
+    const calleeName = (_a = remotionLocalNames[param.interpolationFunction]) !== null && _a !== void 0 ? _a : param.interpolationFunction;
+    const args = [
+        b.identifier('frame'),
+        b.arrayExpression(param.keyframes.map((keyframe) => (0, update_nested_prop_1.parseValueExpression)(keyframe.frame))),
+        b.arrayExpression(param.keyframes.map((keyframe) => (0, update_nested_prop_1.parseValueExpression)(keyframe.value))),
+    ];
+    const options = makeKeyframedOptions({ param, remotionLocalNames });
+    if (options) {
+        args.push(options);
+    }
+    return b.callExpression(b.identifier(calleeName), args);
+};
+const makeParamExpression = ({ param, remotionLocalNames, }) => {
+    if (param.type === 'static') {
+        return (0, update_nested_prop_1.parseValueExpression)(param.value);
+    }
+    return makeKeyframedExpression({ param, remotionLocalNames });
+};
+exports.makeParamExpression = makeParamExpression;

package/dist/codemods/paste-effects.js

@@ -36,14 +36,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pasteEffects = void 0;
 const recast = __importStar(require("recast"));
 const get_ast_node_path_1 = require("../helpers/get-ast-node-path");
-const imports_1 = require("../helpers/imports");
 const can_update_sequence_props_1 = require("../preview-server/routes/can-update-sequence-props");
 const add_effect_1 = require("./add-effect");
+const effect_param_expression_1 = require("./effect-param-expression");
 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 ensure_imports_and_frame_hook_1 = require("./update-keyframes/ensure-imports-and-frame-hook");
-const update_nested_prop_1 = require("./update-nested-prop");
 const b = recast.types.builders;
 const identifierRegex = /^[A-Za-z_$][0-9A-Za-z_$]*$/;
 const getEffectsArray = (attr) => {
@@ -62,98 +61,12 @@ const makeEffectsAttr = (array) => {
 const makeEffectsArray = (calls) => {
     return b.arrayExpression(calls);
 };
-const isNonLinearEasing = (easing) => easing !== 'linear';
-const keyframedParamNeedsEasingImport = (param) => {
-    return (param.interpolationFunction !== 'interpolateColors' &&
-        param.easing.some(isNonLinearEasing));
-};
-const getRequiredRemotionImports = (effects) => {
-    const requiredImports = new Set();
-    for (const effect of effects) {
-        for (const param of Object.values(effect.params)) {
-            if (param.type !== 'keyframed') {
-                continue;
-            }
-            requiredImports.add('useCurrentFrame');
-            requiredImports.add(param.interpolationFunction);
-            if (keyframedParamNeedsEasingImport(param)) {
-                requiredImports.add('Easing');
-            }
-        }
-    }
-    return requiredImports;
-};
-const ensureRemotionImportLocalNames = ({ ast, requiredImports, }) => {
-    const localNames = {};
-    for (const importedName of requiredImports) {
-        localNames[importedName] = (0, imports_1.ensureNamedImport)({
-            ast,
-            importedName,
-            sourcePath: 'remotion',
-            localName: importedName,
-        });
-    }
-    return localNames;
-};
-const makeEasingExpression = ({ easing, easingLocalName, }) => {
-    if (easing === 'linear') {
-        return b.memberExpression(b.identifier(easingLocalName), b.identifier('linear'));
-    }
-    return b.callExpression(b.memberExpression(b.identifier(easingLocalName), b.identifier('bezier')), easing.map((value) => (0, update_nested_prop_1.parseValueExpression)(value)));
-};
-const makeKeyframedOptions = ({ param, remotionLocalNames, }) => {
-    var _a;
-    const properties = [];
-    if (param.interpolationFunction !== 'interpolateColors') {
-        if (param.clamping.left !== 'extend') {
-            properties.push(b.objectProperty(b.identifier('extrapolateLeft'), b.stringLiteral(param.clamping.left)));
-        }
-        if (param.clamping.right !== 'extend') {
-            properties.push(b.objectProperty(b.identifier('extrapolateRight'), b.stringLiteral(param.clamping.right)));
-        }
-        if (keyframedParamNeedsEasingImport(param)) {
-            const easingLocalName = (_a = remotionLocalNames.Easing) !== null && _a !== void 0 ? _a : 'Easing';
-            properties.push(b.objectProperty(b.identifier('easing'), b.arrayExpression(param.easing.map((easing) => makeEasingExpression({ easing, easingLocalName })))));
-        }
-    }
-    if (param.posterize !== undefined) {
-        properties.push(b.objectProperty(b.identifier('posterize'), (0, update_nested_prop_1.parseValueExpression)(param.posterize)));
-    }
-    if (properties.length === 0) {
-        return null;
-    }
-    return b.objectExpression(properties);
-};
-const makeKeyframedExpression = ({ param, remotionLocalNames, }) => {
-    var _a;
-    const expectedEasingCount = Math.max(0, param.keyframes.length - 1);
-    if (param.easing.length !== expectedEasingCount) {
-        throw new Error('Cannot paste keyframed effect: invalid easing metadata');
-    }
-    const calleeName = (_a = remotionLocalNames[param.interpolationFunction]) !== null && _a !== void 0 ? _a : param.interpolationFunction;
-    const args = [
-        b.identifier('frame'),
-        b.arrayExpression(param.keyframes.map((keyframe) => (0, update_nested_prop_1.parseValueExpression)(keyframe.frame))),
-        b.arrayExpression(param.keyframes.map((keyframe) => (0, update_nested_prop_1.parseValueExpression)(keyframe.value))),
-    ];
-    const options = makeKeyframedOptions({ param, remotionLocalNames });
-    if (options) {
-        args.push(options);
-    }
-    return b.callExpression(b.identifier(calleeName), args);
-};
-const makeParamExpression = ({ param, remotionLocalNames, }) => {
-    if (param.type === 'static') {
-        return (0, update_nested_prop_1.parseValueExpression)(param.value);
-    }
-    return makeKeyframedExpression({ param, remotionLocalNames });
-};
 const makeParamsObjectExpression = ({ params, remotionLocalNames, }) => {
     return b.objectExpression(Object.entries(params).map(([key, param]) => {
         const keyNode = identifierRegex.test(key)
             ? b.identifier(key)
             : b.stringLiteral(key);
-        return b.objectProperty(keyNode, makeParamExpression({ param, remotionLocalNames }));
+        return b.objectProperty(keyNode, (0, effect_param_expression_1.makeParamExpression)({ param, remotionLocalNames }));
     }));
 };
 const makeEffectCall = ({ ast, effect, remotionLocalNames, }) => {
@@ -188,8 +101,8 @@ const pasteEffects = async ({ input, targetSequenceNodePath, type, effects, pret
     if (!targetJsx || !targetJsxPath) {
         throw new Error('Could not find a JSX element at the specified location to paste effects');
     }
-    const requiredRemotionImports = getRequiredRemotionImports(effects);
-    const remotionLocalNames = ensureRemotionImportLocalNames({
+    const requiredRemotionImports = (0, effect_param_expression_1.getRequiredRemotionImports)(effects);
+    const remotionLocalNames = (0, effect_param_expression_1.ensureRemotionImportLocalNames)({
         ast,
         requiredImports: requiredRemotionImports,
     });

package/dist/codemods/reorder-sequence.d.ts

@@ -0,0 +1,14 @@
+import type { ReorderSequencePosition } from '@remotion/studio-shared';
+import type { SequenceNodePath } from 'remotion';
+export declare const reorderSequence: ({ input, sourceNodePath, targetNodePath, position, prettierConfigOverride, }: {
+    input: string;
+    sourceNodePath: SequenceNodePath;
+    targetNodePath: SequenceNodePath;
+    position: ReorderSequencePosition;
+    prettierConfigOverride?: Record<string, unknown> | null | undefined;
+}) => Promise<{
+    output: string;
+    formatted: boolean;
+    sequenceLabel: string;
+    logLine: number;
+}>;

package/dist/codemods/reorder-sequence.js

@@ -0,0 +1,109 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reorderSequence = void 0;
+const recast = __importStar(require("recast"));
+const delete_jsx_node_1 = require("./delete-jsx-node");
+const format_file_content_1 = require("./format-file-content");
+const parse_ast_1 = require("./parse-ast");
+const { namedTypes } = recast.types;
+const getJsxChildrenParent = (path) => {
+    var _a;
+    const parent = (_a = path.parentPath) === null || _a === void 0 ? void 0 : _a.node;
+    if (!parent) {
+        return null;
+    }
+    if (namedTypes.JSXElement.check(parent)) {
+        return parent;
+    }
+    if (namedTypes.JSXFragment.check(parent)) {
+        return parent;
+    }
+    return null;
+};
+const reorderSequence = async ({ input, sourceNodePath, targetNodePath, position, prettierConfigOverride, }) => {
+    var _a, _b;
+    var _c, _d;
+    const ast = (0, parse_ast_1.parseAst)(input);
+    const sourcePath = (0, delete_jsx_node_1.findJsxElementPathForDeletion)(ast, sourceNodePath);
+    if (!sourcePath) {
+        throw new Error('Could not find a JSX element at the source location to reorder sequence');
+    }
+    const targetPath = (0, delete_jsx_node_1.findJsxElementPathForDeletion)(ast, targetNodePath);
+    if (!targetPath) {
+        throw new Error('Could not find a JSX element at the target location to reorder sequence');
+    }
+    const sourceParent = getJsxChildrenParent(sourcePath);
+    const targetParent = getJsxChildrenParent(targetPath);
+    if (!sourceParent || !targetParent || sourceParent !== targetParent) {
+        throw new Error('Cannot reorder sequence: source and target are not JSX siblings');
+    }
+    const sourceElement = sourcePath.node;
+    const targetElement = targetPath.node;
+    if (sourceElement === targetElement) {
+        throw new Error('Cannot reorder sequence: source and target are identical');
+    }
+    const { children } = sourceParent;
+    const sourceIndex = children.indexOf(sourceElement);
+    const targetIndex = children.indexOf(targetElement);
+    if (sourceIndex === -1 || targetIndex === -1) {
+        throw new Error('Cannot reorder sequence: JSX sibling was not found');
+    }
+    const sequenceLabel = (0, delete_jsx_node_1.getJsxElementTagLabel)(sourceElement);
+    const logLine = (_d = (_c = (_a = sourceElement.openingElement.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _c !== void 0 ? _c : (_b = sourceElement.loc) === null || _b === void 0 ? void 0 : _b.start.line) !== null && _d !== void 0 ? _d : 1;
+    const [moved] = children.splice(sourceIndex, 1);
+    if (!moved) {
+        throw new Error('Cannot reorder sequence: source sequence was not found');
+    }
+    const targetIndexAfterRemoval = children.indexOf(targetElement);
+    if (targetIndexAfterRemoval === -1) {
+        throw new Error('Cannot reorder sequence: target sequence was not found');
+    }
+    children.splice(position === 'before'
+        ? targetIndexAfterRemoval
+        : targetIndexAfterRemoval + 1, 0, moved);
+    const finalFile = (0, parse_ast_1.serializeAst)(ast);
+    const { output, formatted } = await (0, format_file_content_1.formatFileContent)({
+        input: finalFile,
+        prettierConfigOverride,
+    });
+    return {
+        output,
+        formatted,
+        sequenceLabel,
+        logLine,
+    };
+};
+exports.reorderSequence = reorderSequence;

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

@@ -1,14 +1,20 @@
 import type { ArrayExpression, CallExpression, JSXAttribute } from '@babel/types';
+import type { EffectClipboardParam } from '@remotion/studio-shared';
 import type { SequenceNodePath, SequenceSchema } from 'remotion';
 export type EffectPropUpdate = {
     key: string;
     value: unknown;
     defaultValue: unknown | null;
+} | {
+    key: string;
+    effectParam: EffectClipboardParam;
+    defaultValue: unknown | null;
 };
 export type UpdateEffectPropsResult = {
     output: string;
     formatted: boolean;
     oldValueString: string;
+    newValueString: string;
     logLine: number;
     effectCallee: string;
     removedProps: PropDelta[];
@@ -47,6 +53,7 @@ export declare const updateEffectPropsAst: ({ input, sequenceNodePath, effectInd
 }) => {
     serialized: string;
     oldValueString: string;
+    newValueString: string;
     logLine: number;
     effectCallee: string;
     removedProps: PropDelta[];

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

@@ -34,23 +34,16 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 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 no_react_1 = require("remotion/no-react");
+const get_ast_node_path_1 = require("../../helpers/get-ast-node-path");
 const can_update_sequence_props_1 = require("../../preview-server/routes/can-update-sequence-props");
+const effect_param_expression_1 = require("../effect-param-expression");
 const format_file_content_1 = require("../format-file-content");
 const parse_ast_1 = require("../parse-ast");
+const ensure_imports_and_frame_hook_1 = require("../update-keyframes/ensure-imports-and-frame-hook");
+const update_nested_prop_1 = require("../update-nested-prop");
 const b = recast.types.builders;
-const parseValueExpression = (value) => {
-    const code = `a = ${(0, studio_shared_1.stringifyDefaultProps)({ props: value, enumPaths: [] })}`;
-    const ast = (0, parse_ast_1.parseAst)(code);
-    const stmt = ast.program.body[0];
-    if (stmt.type !== 'ExpressionStatement' ||
-        stmt.expression.type !== 'AssignmentExpression') {
-        throw new Error('Failed to parse effect prop value expression');
-    }
-    return stmt.expression.right;
-};
 const findEffectsAttr = (attrs) => {
     for (const attr of attrs) {
         if (attr.type !== 'JSXAttribute') {
@@ -138,6 +131,47 @@ const printObjectPropertyValue = (prop) => recast
     .code.replace(/[\n\r\t]+/g, ' ')
     .replace(/,(\s*[}\]])/g, '$1')
     .trim();
+const updateHasEffectParam = (update) => 'effectParam' in update;
+const getStaticUpdateValue = (update) => {
+    if (updateHasEffectParam(update)) {
+        return update.effectParam.type === 'static'
+            ? update.effectParam.value
+            : null;
+    }
+    return update.value;
+};
+const ensureClipboardParamImports = ({ ast, sequenceNodePath, param, }) => {
+    var _a;
+    const requiredImports = (0, effect_param_expression_1.getRequiredRemotionImportsForEffectParams)([param]);
+    const remotionLocalNames = (0, effect_param_expression_1.ensureRemotionImportLocalNames)({
+        ast,
+        requiredImports,
+    });
+    if (requiredImports.has('useCurrentFrame')) {
+        const targetJsxPath = (0, get_ast_node_path_1.getAstNodePath)(ast, sequenceNodePath);
+        if (targetJsxPath) {
+            const fnPath = (0, ensure_imports_and_frame_hook_1.findEnclosingFunctionPath)(targetJsxPath);
+            if (fnPath) {
+                (0, ensure_imports_and_frame_hook_1.ensureUseCurrentFrameHook)(fnPath, (_a = remotionLocalNames.useCurrentFrame) !== null && _a !== void 0 ? _a : 'useCurrentFrame');
+            }
+        }
+    }
+    return remotionLocalNames;
+};
+const makeUpdateValueExpression = ({ ast, sequenceNodePath, update, }) => {
+    if (!updateHasEffectParam(update)) {
+        return (0, update_nested_prop_1.parseValueExpression)(update.value);
+    }
+    const remotionLocalNames = ensureClipboardParamImports({
+        ast,
+        sequenceNodePath,
+        param: update.effectParam,
+    });
+    return (0, effect_param_expression_1.makeParamExpression)({
+        param: update.effectParam,
+        remotionLocalNames,
+    });
+};
 const removeObjectProperty = ({ objExpr, propertyName, }) => {
     const { propIndex, prop } = findObjectProperty(objExpr, propertyName);
     if (!prop || propIndex === -1) {
@@ -170,7 +204,8 @@ const updateEffectPropsAst = ({ input, sequenceNodePath, effectIndex, update, sc
         throw new Error(`Cannot update effect prop: ${found.reason}`);
     }
     const { call, callee: effectCallee } = found;
-    const isDefault = update.defaultValue !== null &&
+    const isDefault = !updateHasEffectParam(update) &&
+        update.defaultValue !== null &&
         JSON.stringify(update.value) === JSON.stringify(update.defaultValue);
     let objExpr;
     if (call.arguments.length === 0) {
@@ -178,6 +213,7 @@ const updateEffectPropsAst = ({ input, sequenceNodePath, effectIndex, update, sc
             return {
                 serialized: (0, parse_ast_1.serializeAst)(ast),
                 oldValueString: '',
+                newValueString: JSON.stringify(update.defaultValue),
                 logLine: (_g = (_f = (_a = call.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _f !== void 0 ? _f : (_b = jsx.loc) === null || _b === void 0 ? void 0 : _b.start.line) !== null && _g !== void 0 ? _g : 1,
                 effectCallee,
                 removedProps: [],
@@ -201,7 +237,9 @@ const updateEffectPropsAst = ({ input, sequenceNodePath, effectIndex, update, sc
     else if (update.defaultValue !== null) {
         oldValueString = JSON.stringify(update.defaultValue);
     }
+    let newValueString = '';
     if (isDefault) {
+        newValueString = JSON.stringify(update.defaultValue);
         if (prop) {
             const idx = objExpr.properties.indexOf(prop);
             if (idx !== -1) {
@@ -210,7 +248,12 @@ const updateEffectPropsAst = ({ input, sequenceNodePath, effectIndex, update, sc
         }
     }
     else {
-        const newValueExpr = parseValueExpression(update.value);
+        const newValueExpr = makeUpdateValueExpression({
+            ast,
+            sequenceNodePath,
+            update,
+        });
+        newValueString = recast.print(newValueExpr).code;
         if (prop) {
             prop.value = newValueExpr;
         }
@@ -219,11 +262,14 @@ const updateEffectPropsAst = ({ input, sequenceNodePath, effectIndex, update, sc
         }
     }
     const fieldSchema = schema[update.key];
-    if (fieldSchema && fieldSchema.type === 'enum') {
+    const staticUpdateValue = getStaticUpdateValue(update);
+    if (fieldSchema &&
+        fieldSchema.type === 'enum' &&
+        staticUpdateValue !== null) {
         const propsToDelete = no_react_1.NoReactInternals.findPropsToDelete({
             schema,
             key: update.key,
-            value: update.value,
+            value: staticUpdateValue,
         });
         for (const propToDelete of propsToDelete) {
             const removed = removeObjectProperty({
@@ -239,6 +285,7 @@ const updateEffectPropsAst = ({ input, sequenceNodePath, effectIndex, update, sc
     return {
         serialized: (0, parse_ast_1.serializeAst)(ast),
         oldValueString,
+        newValueString,
         logLine,
         effectCallee,
         removedProps,
@@ -246,7 +293,7 @@ const updateEffectPropsAst = ({ input, sequenceNodePath, effectIndex, update, sc
 };
 exports.updateEffectPropsAst = updateEffectPropsAst;
 const updateEffectProps = async ({ input, sequenceNodePath, effectIndex, update, schema, prettierConfigOverride, }) => {
-    const { serialized, oldValueString, logLine, effectCallee, removedProps } = (0, exports.updateEffectPropsAst)({
+    const { serialized, oldValueString, newValueString, logLine, effectCallee, removedProps, } = (0, exports.updateEffectPropsAst)({
         input,
         sequenceNodePath,
         effectIndex,
@@ -260,6 +307,7 @@ const updateEffectProps = async ({ input, sequenceNodePath, effectIndex, update,
     return {
         output,
         oldValueString,
+        newValueString,
         formatted,
         logLine,
         effectCallee,

package/dist/codemods/update-keyframes/update-keyframes.d.ts

@@ -1,5 +1,5 @@
 import { type KeyframeInterpolationFunction } from '@remotion/studio-shared';
-import type { SequenceNodePath, SequenceSchema } from 'remotion';
+import type { ExtrapolateType, SequenceNodePath, SequenceSchema } from 'remotion';
 export type KeyframeOperation = {
     type: 'add';
     frame: number;
@@ -7,6 +7,19 @@ export type KeyframeOperation = {
 } | {
     type: 'remove';
     frame: number;
+} | {
+    type: 'settings';
+    clamping: {
+        left: ExtrapolateType;
+        right: ExtrapolateType;
+    } | undefined;
+    posterize: number | undefined;
+} | {
+    type: 'move';
+    moves: {
+        fromFrame: number;
+        toFrame: number;
+    }[];
 };
 export type SequenceKeyframeUpdate = {
     key: string;