@remotion/studio-server 4.0.471 → 4.0.473

package/dist/codemods/update-keyframes/ensure-imports-and-frame-hook.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureUseCurrentFrameHook = exports.ensureRemotionImports = exports.findEnclosingFunctionPath = void 0;
 const recast = __importStar(require("recast"));
+const imports_1 = require("../../helpers/imports");
 const b = recast.types.builders;
 const n = recast.types.namedTypes;
 const isFunctionNode = (value) => {
@@ -53,60 +54,11 @@ const findEnclosingFunctionPath = (path) => {
     return null;
 };
 exports.findEnclosingFunctionPath = findEnclosingFunctionPath;
-const findRemotionImport = (ast) => {
-    for (const stmt of ast.program.body) {
-        if (stmt.type === 'ImportDeclaration' &&
-            stmt.source.type === 'StringLiteral' &&
-            stmt.source.value === 'remotion') {
-            return stmt;
-        }
-    }
-    return null;
-};
-const insertImportDeclaration = (ast, importDecl) => {
-    const { body } = ast.program;
-    let lastImportIndex = -1;
-    for (let i = 0; i < body.length; i++) {
-        if (body[i].type === 'ImportDeclaration') {
-            lastImportIndex = i;
-        }
-    }
-    body.splice(lastImportIndex + 1, 0, importDecl);
-};
 const ensureRemotionImports = (ast, names) => {
-    var _a, _b;
-    if (names.size === 0) {
-        return;
-    }
-    let remotionImport = findRemotionImport(ast);
-    if (!remotionImport) {
-        remotionImport = b.importDeclaration([], b.stringLiteral('remotion'));
-        insertImportDeclaration(ast, remotionImport);
-    }
-    const existingNames = new Set();
-    for (const specifier of (_a = remotionImport.specifiers) !== null && _a !== void 0 ? _a : []) {
-        if (specifier.type !== 'ImportSpecifier') {
-            continue;
-        }
-        const { imported } = specifier;
-        if (imported.type === 'Identifier') {
-            existingNames.add(imported.name);
-        }
-        else if (imported.type === 'StringLiteral') {
-            existingNames.add(imported.value);
-        }
-    }
-    for (const name of names) {
-        if (existingNames.has(name)) {
-            continue;
-        }
-        remotionImport.specifiers = (_b = remotionImport.specifiers) !== null && _b !== void 0 ? _b : [];
-        remotionImport.specifiers.push(b.importSpecifier(b.identifier(name)));
-        existingNames.add(name);
-    }
+    (0, imports_1.ensureNamedImports)({ ast, importedNames: names, sourcePath: 'remotion' });
 };
 exports.ensureRemotionImports = ensureRemotionImports;
-const componentBodyHasFrameDeclaration = (body) => {
+const componentBodyHasFrameDeclaration = ({ body, hookName, }) => {
     if (!n.BlockStatement.check(body)) {
         return false;
     }
@@ -123,14 +75,14 @@ const componentBodyHasFrameDeclaration = (body) => {
                 decl.init &&
                 decl.init.type === 'CallExpression' &&
                 decl.init.callee.type === 'Identifier' &&
-                decl.init.callee.name === 'useCurrentFrame') {
+                decl.init.callee.name === hookName) {
                 return true;
             }
         }
     }
     return false;
 };
-const ensureUseCurrentFrameHook = (functionPath) => {
+const ensureUseCurrentFrameHook = (functionPath, hookName = 'useCurrentFrame') => {
     const fn = functionPath.value;
     if (!n.BlockStatement.check(fn.body)) {
         // Arrow function with expression body: wrap the expression in a block so
@@ -140,12 +92,12 @@ const ensureUseCurrentFrameHook = (functionPath) => {
             b.returnStatement(expression),
         ]);
     }
-    if (componentBodyHasFrameDeclaration(fn.body)) {
+    if (componentBodyHasFrameDeclaration({ body: fn.body, hookName })) {
         return;
     }
     const block = fn.body;
     const frameDecl = b.variableDeclaration('const', [
-        b.variableDeclarator(b.identifier('frame'), b.callExpression(b.identifier('useCurrentFrame'), [])),
+        b.variableDeclarator(b.identifier('frame'), b.callExpression(b.identifier(hookName), [])),
     ]);
     block.body.unshift(frameDecl);
 };

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

@@ -1,4 +1,5 @@
-import type { SequenceNodePath } from 'remotion';
+import { type KeyframeInterpolationFunction } from '@remotion/studio-shared';
+import type { ExtrapolateType, SequenceNodePath, SequenceSchema } from 'remotion';
 export type KeyframeOperation = {
     type: 'add';
     frame: number;
@@ -6,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;
@@ -16,13 +30,14 @@ export type EffectKeyframeUpdate = {
     operation: KeyframeOperation;
 };
 export type IntroducedKeyframeIdentifiers = {
-    calleeName: 'interpolate' | 'interpolateColors' | null;
+    calleeName: KeyframeInterpolationFunction | null;
     needsFrameHook: boolean;
 };
-export declare const updateSequenceKeyframesAst: ({ input, nodePath, updates, }: {
+export declare const updateSequenceKeyframesAst: ({ input, nodePath, updates, schema, }: {
     input: string;
     nodePath: SequenceNodePath;
     updates: SequenceKeyframeUpdate[];
+    schema?: SequenceSchema | undefined;
 }) => {
     serialized: string;
     oldValueStrings: string[];
@@ -30,10 +45,11 @@ export declare const updateSequenceKeyframesAst: ({ input, nodePath, updates, }:
     logLine: number;
     updatedNodePath: SequenceNodePath;
 };
-export declare const updateSequenceKeyframes: ({ input, nodePath, updates, prettierConfigOverride, }: {
+export declare const updateSequenceKeyframes: ({ input, nodePath, updates, schema, prettierConfigOverride, }: {
     input: string;
     nodePath: SequenceNodePath;
     updates: SequenceKeyframeUpdate[];
+    schema?: SequenceSchema | undefined;
     prettierConfigOverride?: Record<string, unknown> | null | undefined;
 }) => Promise<{
     output: string;
@@ -43,11 +59,12 @@ export declare const updateSequenceKeyframes: ({ input, nodePath, updates, prett
     logLine: number;
     updatedNodePath: SequenceNodePath;
 }>;
-export declare const updateEffectKeyframesAst: ({ input, sequenceNodePath, effectIndex, updates, }: {
+export declare const updateEffectKeyframesAst: ({ input, sequenceNodePath, effectIndex, updates, schema, }: {
     input: string;
     sequenceNodePath: SequenceNodePath;
     effectIndex: number;
     updates: EffectKeyframeUpdate[];
+    schema?: SequenceSchema | undefined;
 }) => {
     serialized: string;
     oldValueStrings: string[];
@@ -56,11 +73,12 @@ export declare const updateEffectKeyframesAst: ({ input, sequenceNodePath, effec
     effectCallee: string;
     updatedSequenceNodePath: SequenceNodePath;
 };
-export declare const updateEffectKeyframes: ({ input, sequenceNodePath, effectIndex, updates, prettierConfigOverride, }: {
+export declare const updateEffectKeyframes: ({ input, sequenceNodePath, effectIndex, updates, schema, prettierConfigOverride, }: {
     input: string;
     sequenceNodePath: SequenceNodePath;
     effectIndex: number;
     updates: EffectKeyframeUpdate[];
+    schema?: SequenceSchema | undefined;
     prettierConfigOverride?: Record<string, unknown> | null | undefined;
 }) => Promise<{
     output: string;

package/dist/codemods/update-keyframes/update-keyframes.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateEffectKeyframes = exports.updateEffectKeyframesAst = exports.updateSequenceKeyframes = exports.updateSequenceKeyframesAst = void 0;
+const studio_shared_1 = require("@remotion/studio-shared");
 const recast = __importStar(require("recast"));
 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");
@@ -71,8 +72,7 @@ const getInterpolationExpression = (node) => {
     }
     if (node.type !== 'CallExpression' ||
         node.callee.type !== 'Identifier' ||
-        (node.callee.name !== 'interpolate' &&
-            node.callee.name !== 'interpolateColors')) {
+        !(0, studio_shared_1.isKeyframeInterpolationFunction)(node.callee.name)) {
         return null;
     }
     const frameArg = getSupportedCallArgument(node.arguments[0]);
@@ -124,14 +124,109 @@ const getInterpolationExpression = (node) => {
         keyframes,
     };
 };
-const getInterpolationCalleeForValues = ({ staticValue, newValue, }) => {
-    return b.identifier(typeof staticValue === 'string' && typeof newValue === 'string'
-        ? 'interpolateColors'
-        : 'interpolate');
+const getInterpolationCalleeForValues = ({ schema, key, staticValue, newValue, }) => {
+    return b.identifier((0, studio_shared_1.getKeyframeInterpolationFunction)({
+        schema,
+        key,
+        staticValue,
+        newValue,
+    }));
 };
 const createFrameExpression = (frame) => {
     return (0, update_nested_prop_1.parseValueExpression)(frame);
 };
+const createClampOptionsExpression = () => {
+    return b.objectExpression([
+        b.objectProperty(b.identifier('extrapolateLeft'), b.stringLiteral('clamp')),
+        b.objectProperty(b.identifier('extrapolateRight'), b.stringLiteral('clamp')),
+    ]);
+};
+const createEmptyOptionsExpression = () => b.objectExpression([]);
+const findObjectOptionProperty = (options, propertyName) => {
+    const propIndex = options.properties.findIndex((prop) => prop.type === 'ObjectProperty' &&
+        !prop.computed &&
+        ((prop.key.type === 'Identifier' && prop.key.name === propertyName) ||
+            (prop.key.type === 'StringLiteral' && prop.key.value === propertyName)));
+    return {
+        propIndex,
+        prop: propIndex === -1
+            ? undefined
+            : options.properties[propIndex],
+    };
+};
+const setOptionsProperty = ({ options, propertyName, value, }) => {
+    const { propIndex, prop } = findObjectOptionProperty(options, propertyName);
+    if (value === null) {
+        if (propIndex !== -1) {
+            options.properties.splice(propIndex, 1);
+        }
+        return;
+    }
+    if (prop) {
+        prop.value = value;
+        return;
+    }
+    options.properties.push(b.objectProperty(b.identifier(propertyName), value));
+};
+const validatePosterize = (posterize) => {
+    if (posterize === undefined) {
+        return;
+    }
+    if (!Number.isFinite(posterize) || posterize <= 0) {
+        throw new Error('Cannot update keyframe settings: posterize must be > 0');
+    }
+};
+const updateKeyframeSettings = ({ expression, clamping, posterize, }) => {
+    validatePosterize(posterize);
+    const existing = getInterpolationExpression(expression);
+    if (!existing) {
+        throw new Error('Cannot update keyframe settings on non-keyframed value');
+    }
+    const calleeName = existing.callee.type === 'Identifier' ? existing.callee.name : null;
+    const isColorInterpolation = calleeName === 'interpolateColors';
+    const extraArgs = [...existing.extraArgs];
+    const existingOptions = extraArgs[0];
+    if (existingOptions && existingOptions.type !== 'ObjectExpression') {
+        throw new Error('Cannot update keyframe settings: options must be inline');
+    }
+    const options = (existingOptions === null || existingOptions === void 0 ? void 0 : existingOptions.type) === 'ObjectExpression'
+        ? existingOptions
+        : createEmptyOptionsExpression();
+    if (isColorInterpolation) {
+        setOptionsProperty({ options, propertyName: 'extrapolateLeft', value: null });
+        setOptionsProperty({
+            options,
+            propertyName: 'extrapolateRight',
+            value: null,
+        });
+    }
+    else if (clamping) {
+        setOptionsProperty({
+            options,
+            propertyName: 'extrapolateLeft',
+            value: b.stringLiteral(clamping.left),
+        });
+        setOptionsProperty({
+            options,
+            propertyName: 'extrapolateRight',
+            value: b.stringLiteral(clamping.right),
+        });
+    }
+    setOptionsProperty({
+        options,
+        propertyName: 'posterize',
+        value: posterize === undefined ? null : b.numericLiteral(posterize),
+    });
+    const nextExtraArgs = options.properties.length === 0
+        ? extraArgs.slice(1)
+        : [options, ...extraArgs.slice(1)];
+    return createInterpolateExpression({
+        callee: existing.callee,
+        input: existing.input,
+        extraArgs: nextExtraArgs,
+        keyframes: existing.keyframes,
+    });
+};
 const createInterpolateExpression = ({ callee, input, extraArgs, keyframes, }) => {
     const sortedKeyframes = [...keyframes].sort((first, second) => first.frame - second.frame);
     return b.callExpression(callee, [
@@ -145,10 +240,21 @@ const noIntroducedIdentifiers = {
     calleeName: null,
     needsFrameHook: false,
 };
-const addKeyframe = ({ expression, frame, value, }) => {
+const addKeyframe = ({ expression, key, frame, value, schema, }) => {
+    if (!(0, studio_shared_1.isSchemaFieldKeyframable)({ schema, key })) {
+        throw new Error(`Cannot add keyframe: "${key}" is not keyframable`);
+    }
     const existing = getInterpolationExpression(expression);
     const newOutput = (0, update_nested_prop_1.parseValueExpression)(value);
     if (existing) {
+        const existingCalleeName = existing.callee.type === 'Identifier'
+            ? existing.callee.name
+            : 'interpolate';
+        const schemaCalleeName = (0, studio_shared_1.getKeyframeInterpolationFunctionForSchemaField)({
+            schema,
+            key,
+        });
+        const nextCalleeName = schemaCalleeName !== null && schemaCalleeName !== void 0 ? schemaCalleeName : existingCalleeName;
         const existingIndex = existing.keyframes.findIndex((keyframe) => keyframe.frame === frame);
         const nextKeyframes = existingIndex === -1
             ? [...existing.keyframes, { frame, output: newOutput, value }]
@@ -157,12 +263,17 @@ const addKeyframe = ({ expression, frame, value, }) => {
                 : keyframe);
         return {
             expression: createInterpolateExpression({
-                callee: existing.callee,
+                callee: b.identifier(nextCalleeName),
                 input: existing.input,
                 extraArgs: existing.extraArgs,
                 keyframes: nextKeyframes,
             }),
-            introduced: noIntroducedIdentifiers,
+            introduced: {
+                calleeName: schemaCalleeName && schemaCalleeName !== existingCalleeName
+                    ? schemaCalleeName
+                    : null,
+                needsFrameHook: false,
+            },
         };
     }
     if (!(0, can_update_sequence_props_1.isStaticValue)(expression)) {
@@ -171,14 +282,19 @@ const addKeyframe = ({ expression, frame, value, }) => {
     const staticValue = (0, can_update_sequence_props_1.extractStaticValue)(expression);
     const keyframes = [{ frame, output: newOutput, value }];
     const callee = getInterpolationCalleeForValues({
+        schema,
+        key,
         staticValue,
         newValue: value,
     });
+    const extraArgs = callee.type === 'Identifier' && callee.name === 'interpolateColors'
+        ? []
+        : [createClampOptionsExpression()];
     return {
         expression: createInterpolateExpression({
             callee,
             input: b.identifier('frame'),
-            extraArgs: [],
+            extraArgs,
             keyframes,
         }),
         introduced: {
@@ -209,14 +325,82 @@ const removeKeyframe = ({ expression, frame, }) => {
         keyframes: nextKeyframes,
     });
 };
-const applyKeyframeOperation = ({ expression, operation, }) => {
+const moveKeyframes = ({ expression, moves, }) => {
+    var _a;
+    const existing = getInterpolationExpression(expression);
+    if (!existing) {
+        throw new Error('Cannot move keyframe in non-interpolated expression');
+    }
+    const moveMap = new Map();
+    for (const move of moves) {
+        if (move.fromFrame === move.toFrame) {
+            continue;
+        }
+        if (moveMap.has(move.fromFrame)) {
+            throw new Error(`Cannot move keyframe at frame ${move.fromFrame} twice`);
+        }
+        moveMap.set(move.fromFrame, move.toFrame);
+    }
+    if (moveMap.size === 0) {
+        return expression;
+    }
+    const frames = new Set(existing.keyframes.map((keyframe) => keyframe.frame));
+    for (const fromFrame of moveMap.keys()) {
+        if (!frames.has(fromFrame)) {
+            throw new Error(`Cannot move keyframe at frame ${fromFrame}: not found`);
+        }
+    }
+    const movedFromFrames = new Set(moveMap.keys());
+    const nextFrames = new Set();
+    for (const keyframe of existing.keyframes) {
+        const nextFrame = (_a = moveMap.get(keyframe.frame)) !== null && _a !== void 0 ? _a : keyframe.frame;
+        if (nextFrames.has(nextFrame)) {
+            throw new Error(`Cannot move keyframe to frame ${nextFrame}: frame already exists`);
+        }
+        if (!movedFromFrames.has(keyframe.frame) && moveMap.has(nextFrame)) {
+            throw new Error(`Cannot move keyframe to frame ${nextFrame}: frame already exists`);
+        }
+        nextFrames.add(nextFrame);
+    }
+    return createInterpolateExpression({
+        callee: existing.callee,
+        input: existing.input,
+        extraArgs: existing.extraArgs,
+        keyframes: existing.keyframes.map((keyframe) => {
+            var _a;
+            return ({
+                ...keyframe,
+                frame: (_a = moveMap.get(keyframe.frame)) !== null && _a !== void 0 ? _a : keyframe.frame,
+            });
+        }),
+    });
+};
+const applyKeyframeOperation = ({ expression, key, operation, schema, }) => {
     if (operation.type === 'add') {
         return addKeyframe({
             expression,
+            key,
             frame: operation.frame,
             value: operation.value,
+            schema,
         });
     }
+    if (operation.type === 'settings') {
+        return {
+            expression: updateKeyframeSettings({
+                expression,
+                clamping: operation.clamping,
+                posterize: operation.posterize,
+            }),
+            introduced: noIntroducedIdentifiers,
+        };
+    }
+    if (operation.type === 'move') {
+        return {
+            expression: moveKeyframes({ expression, moves: operation.moves }),
+            introduced: noIntroducedIdentifiers,
+        };
+    }
     return {
         expression: removeKeyframe({ expression, frame: operation.frame }),
         introduced: noIntroducedIdentifiers,
@@ -267,6 +451,30 @@ const findObjectProperty = (objExpr, propertyName) => {
             : objExpr.properties[propIndex],
     };
 };
+const findFieldInSchema = (schema, key) => {
+    if (key in schema) {
+        return schema[key];
+    }
+    for (const field of Object.values(schema)) {
+        if (field.type !== 'enum') {
+            continue;
+        }
+        for (const variant of Object.values(field.variants)) {
+            const found = findFieldInSchema(variant, key);
+            if (found) {
+                return found;
+            }
+        }
+    }
+    return undefined;
+};
+const getInitialValueForMissingProp = ({ schema, key, newValue, }) => {
+    const field = schema ? findFieldInSchema(schema, key) : undefined;
+    if (field && field.type !== 'hidden' && field.default !== undefined) {
+        return field.default;
+    }
+    return newValue;
+};
 const getObjectExpression = (attr) => {
     if (!attr.value || attr.value.type !== 'JSXExpressionContainer') {
         return null;
@@ -276,11 +484,31 @@ const getObjectExpression = (attr) => {
     }
     return attr.value.expression;
 };
-const getSequenceWritableProp = ({ attributes, key, }) => {
+const createJsxExpressionAttribute = (key, expression) => {
+    return b.jsxAttribute(b.jsxIdentifier(key), b.jsxExpressionContainer(expression));
+};
+const createObjectProperty = (key, value) => b.objectProperty(b.identifier(key), value);
+const createObjectExpressionAttribute = ({ parentKey, childKey, expression, }) => {
+    return createJsxExpressionAttribute(parentKey, b.objectExpression([
+        createObjectProperty(childKey, expression),
+    ]));
+};
+const createMissingPropExpression = (missingPropInitialValue) => {
+    return (0, update_nested_prop_1.parseValueExpression)(missingPropInitialValue.value);
+};
+const getSequenceWritableProp = ({ attributes, key, missingPropInitialValue, }) => {
     const dotIndex = key.indexOf('.');
     if (dotIndex === -1) {
         const { attr: topLevelAttr } = findJsxAttribute(attributes, key);
         if (!topLevelAttr) {
+            if (missingPropInitialValue) {
+                return {
+                    expression: createMissingPropExpression(missingPropInitialValue),
+                    setExpression: (nextExpression) => {
+                        attributes.push(createJsxExpressionAttribute(key, nextExpression));
+                    },
+                };
+            }
             throw new Error(`Cannot update keyframes: "${key}" is not set`);
         }
         const expression = getExpressionFromJsxAttribute(topLevelAttr);
@@ -298,6 +526,18 @@ const getSequenceWritableProp = ({ attributes, key, }) => {
     const childKey = key.slice(dotIndex + 1);
     const { attr: parentAttr } = findJsxAttribute(attributes, parentKey);
     if (!parentAttr) {
+        if (missingPropInitialValue) {
+            return {
+                expression: createMissingPropExpression(missingPropInitialValue),
+                setExpression: (nextExpression) => {
+                    attributes.push(createObjectExpressionAttribute({
+                        parentKey,
+                        childKey,
+                        expression: nextExpression,
+                    }));
+                },
+            };
+        }
         throw new Error(`Cannot update keyframes: "${parentKey}" is not set`);
     }
     const objExpr = getObjectExpression(parentAttr);
@@ -306,6 +546,14 @@ const getSequenceWritableProp = ({ attributes, key, }) => {
     }
     const { prop } = findObjectProperty(objExpr, childKey);
     if (!prop) {
+        if (missingPropInitialValue) {
+            return {
+                expression: createMissingPropExpression(missingPropInitialValue),
+                setExpression: (nextExpression) => {
+                    objExpr.properties.push(createObjectProperty(childKey, nextExpression));
+                },
+            };
+        }
         throw new Error(`Cannot update keyframes: "${key}" is not set`);
     }
     return {
@@ -315,7 +563,7 @@ const getSequenceWritableProp = ({ attributes, key, }) => {
         },
     };
 };
-const updateSequenceKeyframesAst = ({ input, nodePath, updates, }) => {
+const updateSequenceKeyframesAst = ({ input, nodePath, updates, schema, }) => {
     var _a;
     var _b;
     const ast = (0, parse_ast_1.parseAst)(input);
@@ -335,11 +583,22 @@ const updateSequenceKeyframesAst = ({ input, nodePath, updates, }) => {
         const prop = getSequenceWritableProp({
             attributes: node.attributes,
             key: update.key,
+            missingPropInitialValue: update.operation.type === 'add'
+                ? {
+                    value: getInitialValueForMissingProp({
+                        schema: schema !== null && schema !== void 0 ? schema : null,
+                        key: update.key,
+                        newValue: update.operation.value,
+                    }),
+                }
+                : null,
         });
         oldValueStrings.push(recast.print(prop.expression).code);
         const { expression: nextExpression, introduced } = applyKeyframeOperation({
             expression: prop.expression,
+            key: update.key,
             operation: update.operation,
+            schema: schema !== null && schema !== void 0 ? schema : null,
         });
         newValueStrings.push(recast.print(nextExpression).code);
         prop.setExpression(nextExpression);
@@ -371,11 +630,12 @@ const updateSequenceKeyframesAst = ({ input, nodePath, updates, }) => {
     };
 };
 exports.updateSequenceKeyframesAst = updateSequenceKeyframesAst;
-const updateSequenceKeyframes = async ({ input, nodePath, updates, prettierConfigOverride, }) => {
+const updateSequenceKeyframes = async ({ input, nodePath, updates, schema, prettierConfigOverride, }) => {
     const { serialized, oldValueStrings, newValueStrings, logLine, updatedNodePath, } = (0, exports.updateSequenceKeyframesAst)({
         input,
         nodePath,
         updates,
+        schema,
     });
     const { output, formatted } = await (0, format_file_content_1.formatFileContent)({
         input: serialized,
@@ -391,7 +651,7 @@ const updateSequenceKeyframes = async ({ input, nodePath, updates, prettierConfi
     };
 };
 exports.updateSequenceKeyframes = updateSequenceKeyframes;
-const updateEffectKeyframesAst = ({ input, sequenceNodePath, effectIndex, updates, }) => {
+const updateEffectKeyframesAst = ({ input, sequenceNodePath, effectIndex, updates, schema, }) => {
     var _a, _b;
     var _c, _d, _e;
     const ast = (0, parse_ast_1.parseAst)(input);
@@ -426,7 +686,9 @@ const updateEffectKeyframesAst = ({ input, sequenceNodePath, effectIndex, update
         oldValueStrings.push(recast.print(prop.value).code);
         const { expression: nextExpression, introduced } = applyKeyframeOperation({
             expression: prop.value,
+            key: update.key,
             operation: update.operation,
+            schema: schema !== null && schema !== void 0 ? schema : null,
         });
         newValueStrings.push(recast.print(nextExpression).code);
         prop.value = nextExpression;
@@ -459,12 +721,13 @@ const updateEffectKeyframesAst = ({ input, sequenceNodePath, effectIndex, update
     };
 };
 exports.updateEffectKeyframesAst = updateEffectKeyframesAst;
-const updateEffectKeyframes = async ({ input, sequenceNodePath, effectIndex, updates, prettierConfigOverride, }) => {
+const updateEffectKeyframes = async ({ input, sequenceNodePath, effectIndex, updates, schema, prettierConfigOverride, }) => {
     const { serialized, oldValueStrings, newValueStrings, logLine, effectCallee, updatedSequenceNodePath, } = (0, exports.updateEffectKeyframesAst)({
         input,
         sequenceNodePath,
         effectIndex,
         updates,
+        schema,
     });
     const { output, formatted } = await (0, format_file_content_1.formatFileContent)({
         input: serialized,

package/dist/helpers/get-ast-node-path.js

@@ -35,9 +35,14 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAstNodePath = void 0;
 const recast = __importStar(require("recast"));
+const import_agnostic_node_path_1 = require("./import-agnostic-node-path");
 const getAstNodePath = (ast, nodePath) => {
+    const resolvedNodePath = (0, import_agnostic_node_path_1.fromImportAgnosticNodePath)({ ast, nodePath });
+    if (!resolvedNodePath) {
+        return null;
+    }
     let current = new recast.types.NodePath(ast);
-    for (const segment of nodePath) {
+    for (const segment of resolvedNodePath) {
         current = current.get(segment);
         if (current.value === null || current.value === undefined) {
             return null;

package/dist/helpers/import-agnostic-node-path.d.ts

@@ -0,0 +1,10 @@
+import type { File } from '@babel/types';
+import type { SequenceNodePath } from 'remotion';
+export declare const toImportAgnosticNodePath: ({ ast, nodePath, }: {
+    ast: File;
+    nodePath: SequenceNodePath;
+}) => SequenceNodePath;
+export declare const fromImportAgnosticNodePath: ({ ast, nodePath, }: {
+    ast: File;
+    nodePath: SequenceNodePath;
+}) => SequenceNodePath | null;