@remotion/studio-server 4.0.470 → 4.0.472

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

@@ -6,6 +6,10 @@ const parse_ast_1 = require("../../codemods/parse-ast");
 const update_effect_props_1 = require("../../codemods/update-effect-props/update-effect-props");
 const resolve_file_inside_project_1 = require("../../helpers/resolve-file-inside-project");
 const can_update_sequence_props_1 = require("./can-update-sequence-props");
+const staticStatus = (codeValue) => ({
+    status: 'static',
+    codeValue,
+});
 const findEffectsAttr = (jsx) => {
     for (const attr of jsx.attributes) {
         if (attr.type !== 'JSXAttribute') {
@@ -27,6 +31,63 @@ const getEffectsArrayElements = (attr) => {
     }
     return (0, update_effect_props_1.enumerateEffectArrayElements)(expr);
 };
+const getImportedName = (specifier) => {
+    var _a, _b;
+    if (!specifier.imported) {
+        return null;
+    }
+    if (specifier.imported.type === 'Identifier') {
+        return (_a = specifier.imported.name) !== null && _a !== void 0 ? _a : null;
+    }
+    return (_b = specifier.imported.value) !== null && _b !== void 0 ? _b : null;
+};
+const resolveEffectImport = ({ ast, call, fallbackCallee, }) => {
+    var _a, _b;
+    var _c;
+    const { callee } = call;
+    if (callee.type === 'Identifier') {
+        const localName = callee.name;
+        for (const node of ast.program.body) {
+            if (node.type !== 'ImportDeclaration') {
+                continue;
+            }
+            const matchingSpecifier = (_a = node.specifiers) === null || _a === void 0 ? void 0 : _a.find((specifier) => {
+                var _a;
+                return (specifier.type === 'ImportSpecifier' &&
+                    ((_a = specifier.local) === null || _a === void 0 ? void 0 : _a.name) === localName);
+            });
+            if ((matchingSpecifier === null || matchingSpecifier === void 0 ? void 0 : matchingSpecifier.type) === 'ImportSpecifier') {
+                return {
+                    callee: (_c = getImportedName(matchingSpecifier)) !== null && _c !== void 0 ? _c : fallbackCallee,
+                    importPath: String(node.source.value),
+                };
+            }
+        }
+    }
+    if (callee.type === 'MemberExpression' &&
+        callee.object.type === 'Identifier' &&
+        callee.property.type === 'Identifier' &&
+        !callee.computed) {
+        const namespaceName = callee.object.name;
+        for (const node of ast.program.body) {
+            if (node.type !== 'ImportDeclaration') {
+                continue;
+            }
+            const matchingSpecifier = (_b = node.specifiers) === null || _b === void 0 ? void 0 : _b.find((specifier) => {
+                var _a;
+                return (specifier.type === 'ImportNamespaceSpecifier' &&
+                    ((_a = specifier.local) === null || _a === void 0 ? void 0 : _a.name) === namespaceName);
+            });
+            if (matchingSpecifier) {
+                return {
+                    callee: callee.property.name,
+                    importPath: String(node.source.value),
+                };
+            }
+        }
+    }
+    return { callee: fallbackCallee, importPath: null };
+};
 const getPropsFromObjectExpression = ({ objExpr, keys, }) => {
     const out = {};
     for (const key of keys) {
@@ -35,7 +96,7 @@ const getPropsFromObjectExpression = ({ objExpr, keys, }) => {
                 (p.key.type === 'StringLiteral' &&
                     p.key.value === key)));
         if (!prop) {
-            out[key] = { canUpdate: true, codeValue: undefined };
+            out[key] = staticStatus(undefined);
             continue;
         }
         const valueExpr = prop.value;
@@ -44,13 +105,13 @@ const getPropsFromObjectExpression = ({ objExpr, keys, }) => {
             continue;
         }
         out[key] = {
-            canUpdate: true,
+            status: 'static',
             codeValue: (0, can_update_sequence_props_1.extractStaticValue)(valueExpr),
         };
     }
     return out;
 };
-const computeEffectPropStatus = ({ jsx, effectIndex, keys, }) => {
+const computeEffectPropStatus = ({ ast, jsx, effectIndex, keys, }) => {
     const attr = findEffectsAttr(jsx);
     const elements = getEffectsArrayElements(attr);
     if (!elements) {
@@ -76,14 +137,20 @@ const computeEffectPropStatus = ({ jsx, effectIndex, keys, }) => {
         };
     }
     const call = target.node;
+    const effectImport = resolveEffectImport({
+        ast,
+        call,
+        fallbackCallee: target.callee,
+    });
     if (call.arguments.length === 0) {
         const emptyProps = {};
         for (const key of keys) {
-            emptyProps[key] = { canUpdate: true, codeValue: undefined };
+            emptyProps[key] = staticStatus(undefined);
         }
         return {
             canUpdate: true,
-            callee: target.callee,
+            callee: effectImport.callee,
+            importPath: effectImport.importPath,
             effectIndex,
             props: emptyProps,
         };
@@ -103,7 +170,8 @@ const computeEffectPropStatus = ({ jsx, effectIndex, keys, }) => {
     return {
         canUpdate: true,
         effectIndex,
-        callee: target.callee,
+        callee: effectImport.callee,
+        importPath: effectImport.importPath,
         props: resolvedProps,
     };
 };
@@ -119,6 +187,7 @@ const computeEffectPropsStatusesFromContent = ({ fileContents, sequenceNodePath,
         }));
     }
     return effects.map((effect, effectIndex) => (0, exports.computeEffectPropStatus)({
+        ast,
         jsx,
         effectIndex,
         keys: keysFor(effect),

package/dist/preview-server/routes/can-update-sequence-props.d.ts

@@ -5,6 +5,7 @@ export declare const isStaticValue: (node: Expression) => boolean;
 export declare const extractStaticValue: (node: Expression) => unknown;
 export declare const getComputedStatus: (node: Expression) => CanUpdateSequencePropStatus;
 export declare const findJsxElementAtNodePath: (ast: File, nodePath: SequenceNodePath) => JSXOpeningElement | null;
+export declare const findNodePathForJsxElement: (ast: File, target: JSXOpeningElement) => SequenceNodePath | null;
 export declare const lineColumnToNodePath: (ast: File, targetLine: number) => SequenceNodePath | null;
 export declare const computeSequencePropsStatusFromContent: ({ fileContents, nodePath, keys, effects, }: {
     fileContents: string;

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

@@ -33,15 +33,24 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.computeSequencePropsStatusFromFilenameByLine = exports.computeSequencePropsStatus = exports.computeSequencePropsStatusFromContent = exports.lineColumnToNodePath = exports.findJsxElementAtNodePath = exports.getComputedStatus = exports.extractStaticValue = exports.isStaticValue = void 0;
+exports.computeSequencePropsStatusFromFilenameByLine = exports.computeSequencePropsStatus = exports.computeSequencePropsStatusFromContent = exports.lineColumnToNodePath = exports.findNodePathForJsxElement = exports.findJsxElementAtNodePath = exports.getComputedStatus = exports.extractStaticValue = exports.isStaticValue = void 0;
 const node_fs_1 = require("node:fs");
 const renderer_1 = require("@remotion/renderer");
+const studio_shared_1 = require("@remotion/studio-shared");
 const recast = __importStar(require("recast"));
 const parse_ast_1 = require("../../codemods/parse-ast");
 const get_ast_node_path_1 = require("../../helpers/get-ast-node-path");
+const import_agnostic_node_path_1 = require("../../helpers/import-agnostic-node-path");
 const resolve_file_inside_project_1 = require("../../helpers/resolve-file-inside-project");
 const jsx_element_not_found_at_location_error_1 = require("../jsx-element-not-found-at-location-error");
 const can_update_effect_props_1 = require("./can-update-effect-props");
+const staticStatus = (codeValue) => ({
+    status: 'static',
+    codeValue,
+});
+const computedStatus = () => ({
+    status: 'computed',
+});
 const isStaticValue = (node) => {
     switch (node.type) {
         case 'NumericLiteral':
@@ -305,8 +314,7 @@ const getInterpolationKeyframes = (node) => {
     }
     const callExpression = node;
     if (callExpression.callee.type !== 'Identifier' ||
-        (callExpression.callee.name !== 'interpolate' &&
-            callExpression.callee.name !== 'interpolateColors')) {
+        !(0, studio_shared_1.isKeyframeInterpolationFunction)(callExpression.callee.name)) {
         return undefined;
     }
     const interpolationFunction = callExpression.callee.name;
@@ -358,11 +366,11 @@ const getInterpolationKeyframes = (node) => {
 const getComputedStatus = (node) => {
     const interpolation = getInterpolationKeyframes(node);
     if (!interpolation) {
-        return { canUpdate: false, reason: 'computed' };
+        return computedStatus();
     }
     return {
-        canUpdate: false,
-        reason: 'keyframed',
+        status: 'keyframed',
+        codeValue: undefined,
         interpolationFunction: interpolation.interpolationFunction,
         keyframes: interpolation.keyframes,
         easing: interpolation.easing,
@@ -386,39 +394,33 @@ const getPropsStatus = (jsxElement) => {
         }
         const { value } = attr;
         if (!value) {
-            props[name] = { canUpdate: true, codeValue: true };
+            props[name] = staticStatus(true);
             continue;
         }
         if (value.type === 'StringLiteral') {
-            props[name] = {
-                canUpdate: true,
-                codeValue: value.value,
-            };
+            props[name] = staticStatus(value.value);
             continue;
         }
         if (value.type === 'JSXExpressionContainer') {
             const { expression } = value;
             if (expression.type === 'JSXEmptyExpression') {
-                props[name] = { canUpdate: false, reason: 'computed' };
+                props[name] = computedStatus();
                 continue;
             }
             if (!(0, exports.isStaticValue)(expression)) {
                 props[name] = (0, exports.getComputedStatus)(expression);
                 continue;
             }
-            props[name] = {
-                canUpdate: true,
-                codeValue: (0, exports.extractStaticValue)(expression),
-            };
+            props[name] = staticStatus((0, exports.extractStaticValue)(expression));
             continue;
         }
-        props[name] = { canUpdate: false, reason: 'computed' };
+        props[name] = computedStatus();
     }
     return props;
 };
 const getNodePathForRecastPath = (
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-recastPath) => {
+recastPath, ast) => {
     const segments = [];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let current = recastPath;
@@ -428,9 +430,9 @@ recastPath) => {
     }
     // Recast paths start with "root" which doesn't correspond to a real AST property
     if (segments.length > 0 && segments[0] === 'root') {
-        return segments.slice(1);
+        return (0, import_agnostic_node_path_1.toImportAgnosticNodePath)({ ast, nodePath: segments.slice(1) });
     }
-    return segments;
+    return (0, import_agnostic_node_path_1.toImportAgnosticNodePath)({ ast, nodePath: segments });
 };
 const findJsxElementAtNodePath = (ast, nodePath) => {
     const current = (0, get_ast_node_path_1.getAstNodePath)(ast, nodePath);
@@ -443,13 +445,27 @@ const findJsxElementAtNodePath = (ast, nodePath) => {
     return null;
 };
 exports.findJsxElementAtNodePath = findJsxElementAtNodePath;
+const findNodePathForJsxElement = (ast, target) => {
+    let foundPath = null;
+    recast.types.visit(ast, {
+        visitJSXOpeningElement(p) {
+            if (p.node === target) {
+                foundPath = getNodePathForRecastPath(p, ast);
+                return false;
+            }
+            return this.traverse(p);
+        },
+    });
+    return foundPath;
+};
+exports.findNodePathForJsxElement = findNodePathForJsxElement;
 const lineColumnToNodePath = (ast, targetLine) => {
     let foundPath = null;
     recast.types.visit(ast, {
         visitJSXOpeningElement(p) {
             const { node } = p;
             if (node.loc && node.loc.start.line === targetLine) {
-                foundPath = getNodePathForRecastPath(p);
+                foundPath = getNodePathForRecastPath(p, ast);
                 return false;
             }
             return this.traverse(p);
@@ -478,16 +494,16 @@ const getNestedPropStatus = (jsxElement, parentKey, childKey) => {
         a.name.name === parentKey);
     if (!attr || !attr.value) {
         // Parent attribute doesn't exist, nested prop can be added
-        return { canUpdate: true, codeValue: undefined };
+        return staticStatus(undefined);
     }
     if (attr.value.type !== 'JSXExpressionContainer') {
-        return { canUpdate: false, reason: 'computed' };
+        return computedStatus();
     }
     const { expression } = attr.value;
     if (expression.type === 'JSXEmptyExpression' ||
         expression.type !== 'ObjectExpression') {
         // Parent is not an object literal (e.g. style={myStyles})
-        return { canUpdate: false, reason: 'computed' };
+        return computedStatus();
     }
     const objExpr = expression;
     const prop = objExpr.properties.find((p) => p.type === 'ObjectProperty' &&
@@ -495,7 +511,7 @@ const getNestedPropStatus = (jsxElement, parentKey, childKey) => {
             (p.key.type === 'StringLiteral' && p.key.value === childKey)));
     if (!prop) {
         // Property not set in the object, can be added
-        return { canUpdate: true, codeValue: undefined };
+        return staticStatus(undefined);
     }
     const propValue = prop.value;
     if (!(0, exports.isStaticValue)(propValue)) {
@@ -503,12 +519,13 @@ const getNestedPropStatus = (jsxElement, parentKey, childKey) => {
     }
     const codeValue = (0, exports.extractStaticValue)(propValue);
     if (!validateStyleValue(childKey, codeValue)) {
-        return { canUpdate: false, reason: 'computed' };
+        return computedStatus();
     }
-    return { canUpdate: true, codeValue };
+    return staticStatus(codeValue);
 };
-const computeEffectsForJsx = ({ jsxElement, effects, }) => {
+const computeEffectsForJsx = ({ ast, jsxElement, effects, }) => {
     return effects.map((effect, effectIndex) => (0, can_update_effect_props_1.computeEffectPropStatus)({
+        ast,
         jsx: jsxElement,
         effectIndex,
         keys: effect,
@@ -526,7 +543,7 @@ const computeSequenceOnlyPropsRecord = ({ jsxElement, keys, }) => {
             filteredProps[key] = allProps[key];
         }
         else {
-            filteredProps[key] = { canUpdate: true, codeValue: undefined };
+            filteredProps[key] = staticStatus(undefined);
         }
     }
     return filteredProps;
@@ -538,7 +555,7 @@ const computeSequencePropsStatusFromContent = ({ fileContents, nodePath, keys, e
         throw new jsx_element_not_found_at_location_error_1.JsxElementNotFoundAtLocationError();
     }
     const filteredProps = computeSequenceOnlyPropsRecord({ jsxElement, keys });
-    const effectsStatuses = computeEffectsForJsx({ jsxElement, effects });
+    const effectsStatuses = computeEffectsForJsx({ ast, jsxElement, effects });
     return {
         canUpdate: true,
         props: filteredProps,

package/dist/preview-server/routes/delete-keyframes.d.ts

@@ -0,0 +1,13 @@
+import type { DeleteEffectKeyframe, DeleteKeyframesRequest, DeleteKeyframesResponse, DeleteSequenceKeyframe, SaveSequencePropsResult } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
+export declare const deleteKeyframes: ({ sequenceKeyframes, effectKeyframes, clientId, remotionRoot, logLevel, }: {
+    sequenceKeyframes: DeleteSequenceKeyframe[];
+    effectKeyframes: DeleteEffectKeyframe[];
+    clientId: string;
+    remotionRoot: string;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+}) => Promise<{
+    sequenceResults: SaveSequencePropsResult[];
+    effectResults: import("remotion").CanUpdateEffectPropsResponse[];
+}>;
+export declare const deleteKeyframesHandler: ApiHandler<DeleteKeyframesRequest, DeleteKeyframesResponse>;

package/dist/preview-server/routes/delete-keyframes.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteKeyframesHandler = exports.deleteKeyframes = void 0;
+const node_fs_1 = require("node:fs");
+const renderer_1 = require("@remotion/renderer");
+const studio_shared_1 = require("@remotion/studio-shared");
+const parse_ast_1 = require("../../codemods/parse-ast");
+const update_keyframes_1 = require("../../codemods/update-keyframes/update-keyframes");
+const file_watcher_1 = require("../../file-watcher");
+const resolve_file_inside_project_1 = require("../../helpers/resolve-file-inside-project");
+const undo_stack_1 = require("../undo-stack");
+const watch_ignore_next_change_1 = require("../watch-ignore-next-change");
+const can_update_effect_props_1 = require("./can-update-effect-props");
+const can_update_sequence_props_1 = require("./can-update-sequence-props");
+const log_effect_update_1 = require("./log-updates/log-effect-update");
+const log_update_1 = require("./log-updates/log-update");
+const save_props_mutex_1 = require("./save-props-mutex");
+const groupBy = (items, getKey) => {
+    var _a;
+    const groups = new Map();
+    for (const item of items) {
+        const key = getKey(item);
+        const group = (_a = groups.get(key)) !== null && _a !== void 0 ? _a : [];
+        group.push(item);
+        groups.set(key, group);
+    }
+    return [...groups.values()];
+};
+const getBatchDescription = ({ totalKeyframes, firstKeyframe, }) => {
+    if (totalKeyframes === 1) {
+        return {
+            undoMessage: `↩️  ${firstKeyframe.key} keyframe restored at frame ${firstKeyframe.frame}`,
+            redoMessage: `↪️  ${firstKeyframe.key} keyframe deleted at frame ${firstKeyframe.frame}`,
+        };
+    }
+    return {
+        undoMessage: `↩️  ${totalKeyframes} keyframes restored`,
+        redoMessage: `↪️  ${totalKeyframes} keyframes deleted`,
+    };
+};
+const deleteKeyframes = async ({ sequenceKeyframes, effectKeyframes, clientId, remotionRoot, logLevel, }) => {
+    var _a, _b;
+    const totalKeyframes = sequenceKeyframes.length + effectKeyframes.length;
+    if (totalKeyframes === 0) {
+        throw new Error('No keyframes were specified for deletion');
+    }
+    const fileGroups = new Map();
+    const resolvedSequenceKeyframes = [];
+    const resolvedEffectKeyframes = [];
+    for (const [index, keyframe] of sequenceKeyframes.entries()) {
+        const { absolutePath, fileRelativeToRoot } = (0, resolve_file_inside_project_1.resolveFileInsideProject)({
+            remotionRoot,
+            fileName: keyframe.fileName,
+            action: 'modify',
+        });
+        const group = (_a = fileGroups.get(absolutePath)) !== null && _a !== void 0 ? _a : {
+            fileRelativeToRoot,
+            sequenceKeyframes: [],
+            effectKeyframes: [],
+        };
+        const resolved = { ...keyframe, index, absolutePath, fileRelativeToRoot };
+        group.sequenceKeyframes.push(resolved);
+        resolvedSequenceKeyframes.push(resolved);
+        fileGroups.set(absolutePath, group);
+    }
+    for (const [index, keyframe] of effectKeyframes.entries()) {
+        const { absolutePath, fileRelativeToRoot } = (0, resolve_file_inside_project_1.resolveFileInsideProject)({
+            remotionRoot,
+            fileName: keyframe.fileName,
+            action: 'modify',
+        });
+        const group = (_b = fileGroups.get(absolutePath)) !== null && _b !== void 0 ? _b : {
+            fileRelativeToRoot,
+            sequenceKeyframes: [],
+            effectKeyframes: [],
+        };
+        const resolved = { ...keyframe, index, absolutePath, fileRelativeToRoot };
+        group.effectKeyframes.push(resolved);
+        resolvedEffectKeyframes.push(resolved);
+        fileGroups.set(absolutePath, group);
+    }
+    const snapshots = [];
+    const outputByPath = new Map();
+    const sequenceLogs = [];
+    const effectLogs = [];
+    for (const [absolutePath, group] of fileGroups) {
+        const fileContents = (0, node_fs_1.readFileSync)(absolutePath, 'utf-8');
+        let output = fileContents;
+        let firstLogLine = Number.POSITIVE_INFINITY;
+        for (const keyframeGroup of groupBy(group.sequenceKeyframes, (keyframe) => JSON.stringify(keyframe.nodePath.nodePath))) {
+            const [firstSequenceKeyframe] = keyframeGroup;
+            if (!firstSequenceKeyframe) {
+                continue;
+            }
+            const result = await (0, update_keyframes_1.updateSequenceKeyframes)({
+                input: output,
+                nodePath: firstSequenceKeyframe.nodePath.nodePath,
+                updates: keyframeGroup.map((keyframe) => ({
+                    key: keyframe.key,
+                    operation: {
+                        type: 'remove',
+                        frame: keyframe.frame,
+                    },
+                })),
+            });
+            output = result.output;
+            firstLogLine = Math.min(firstLogLine, result.logLine);
+            for (const [keyframeIndex, keyframe] of keyframeGroup.entries()) {
+                sequenceLogs.push({
+                    fileRelativeToRoot: keyframe.fileRelativeToRoot,
+                    line: result.logLine,
+                    key: keyframe.key,
+                    oldValueString: result.oldValueStrings[keyframeIndex],
+                    newValueString: result.newValueStrings[keyframeIndex],
+                    formatted: result.formatted,
+                });
+            }
+        }
+        for (const keyframeGroup of groupBy(group.effectKeyframes, (keyframe) => `${JSON.stringify(keyframe.sequenceNodePath.nodePath)}:${keyframe.effectIndex}`)) {
+            const [firstEffectKeyframe] = keyframeGroup;
+            if (!firstEffectKeyframe) {
+                continue;
+            }
+            const result = await (0, update_keyframes_1.updateEffectKeyframes)({
+                input: output,
+                sequenceNodePath: firstEffectKeyframe.sequenceNodePath.nodePath,
+                effectIndex: firstEffectKeyframe.effectIndex,
+                updates: keyframeGroup.map((keyframe) => ({
+                    key: keyframe.key,
+                    operation: {
+                        type: 'remove',
+                        frame: keyframe.frame,
+                    },
+                })),
+            });
+            output = result.output;
+            firstLogLine = Math.min(firstLogLine, result.logLine);
+            for (const [keyframeIndex, keyframe] of keyframeGroup.entries()) {
+                effectLogs.push({
+                    fileRelativeToRoot: keyframe.fileRelativeToRoot,
+                    line: result.logLine,
+                    effectName: result.effectCallee,
+                    propKey: keyframe.key,
+                    oldValueString: result.oldValueStrings[keyframeIndex],
+                    newValueString: result.newValueStrings[keyframeIndex],
+                    formatted: result.formatted,
+                });
+            }
+        }
+        snapshots.push({
+            filePath: absolutePath,
+            oldContents: fileContents,
+            newContents: output,
+            logLine: Number.isFinite(firstLogLine) ? firstLogLine : 1,
+        });
+        outputByPath.set(absolutePath, output);
+    }
+    const [firstKeyframe] = sequenceKeyframes.length > 0 ? sequenceKeyframes : effectKeyframes;
+    if (!firstKeyframe) {
+        throw new Error('No keyframes were specified for deletion');
+    }
+    (0, undo_stack_1.pushTransactionToUndoStack)({
+        snapshots,
+        logLevel,
+        remotionRoot,
+        description: getBatchDescription({ totalKeyframes, firstKeyframe }),
+        entryType: sequenceKeyframes.length > 0 && effectKeyframes.length > 0
+            ? 'keyframe-delete'
+            : sequenceKeyframes.length > 0
+                ? 'sequence-props'
+                : 'effect-props',
+        suppressHmrOnFileRestore: true,
+    });
+    for (const snapshot of snapshots) {
+        (0, undo_stack_1.suppressUndoStackInvalidation)(snapshot.filePath);
+        (0, watch_ignore_next_change_1.suppressBundlerUpdateForFile)(snapshot.filePath);
+        (0, file_watcher_1.writeFileAndNotifyFileWatchers)(snapshot.filePath, snapshot.newContents, clientId);
+    }
+    for (const log of sequenceLogs) {
+        (0, log_update_1.logUpdate)({
+            fileRelativeToRoot: log.fileRelativeToRoot,
+            line: log.line,
+            key: log.key,
+            oldValueString: log.oldValueString,
+            newValueString: log.newValueString,
+            defaultValueString: null,
+            formatted: log.formatted,
+            logLevel,
+            removedProps: [],
+            addedProps: [],
+        });
+    }
+    for (const log of effectLogs) {
+        (0, log_effect_update_1.logEffectUpdate)({
+            fileRelativeToRoot: log.fileRelativeToRoot,
+            line: log.line,
+            effectName: log.effectName,
+            propKey: log.propKey,
+            oldValueString: log.oldValueString,
+            newValueString: log.newValueString,
+            defaultValueString: null,
+            formatted: log.formatted,
+            logLevel,
+            removedProps: [],
+            addedProps: [],
+        });
+    }
+    (0, undo_stack_1.printUndoHint)(logLevel);
+    const sequenceResults = resolvedSequenceKeyframes.map((keyframe) => {
+        const output = outputByPath.get(keyframe.absolutePath);
+        if (!output) {
+            throw new Error('Could not compute sequence keyframe deletion status');
+        }
+        const status = (0, can_update_sequence_props_1.computeSequencePropsStatusFromContent)({
+            fileContents: output,
+            keys: (0, studio_shared_1.getAllSchemaKeys)(keyframe.schema),
+            nodePath: keyframe.nodePath.nodePath,
+            effects: [],
+        });
+        return {
+            fileName: keyframe.fileName,
+            nodePath: keyframe.nodePath,
+            props: status.props,
+        };
+    });
+    const astByPath = new Map();
+    const effectResults = resolvedEffectKeyframes.map((keyframe) => {
+        var _a;
+        const output = outputByPath.get(keyframe.absolutePath);
+        if (!output) {
+            throw new Error('Could not compute effect keyframe deletion status');
+        }
+        const ast = (_a = astByPath.get(keyframe.absolutePath)) !== null && _a !== void 0 ? _a : (0, parse_ast_1.parseAst)(output);
+        astByPath.set(keyframe.absolutePath, ast);
+        const jsx = (0, can_update_sequence_props_1.findJsxElementAtNodePath)(ast, keyframe.sequenceNodePath.nodePath);
+        if (!jsx) {
+            return {
+                canUpdate: false,
+                effectIndex: keyframe.effectIndex,
+                reason: 'not-found',
+            };
+        }
+        return (0, can_update_effect_props_1.computeEffectPropStatus)({
+            ast,
+            jsx,
+            effectIndex: keyframe.effectIndex,
+            keys: (0, studio_shared_1.getAllSchemaKeys)(keyframe.schema),
+        });
+    });
+    return { sequenceResults, effectResults };
+};
+exports.deleteKeyframes = deleteKeyframes;
+const deleteKeyframesHandler = ({ input: { sequenceKeyframes, effectKeyframes, clientId }, remotionRoot, logLevel, }) => (0, save_props_mutex_1.withSavePropsLock)(async () => {
+    renderer_1.RenderInternals.Log.trace({ indent: false, logLevel }, `[delete-keyframes] Received request to delete ${sequenceKeyframes.length + effectKeyframes.length} keyframe(s)`);
+    await (0, exports.deleteKeyframes)({
+        sequenceKeyframes,
+        effectKeyframes,
+        clientId,
+        remotionRoot,
+        logLevel,
+    });
+    return { success: true };
+});
+exports.deleteKeyframesHandler = deleteKeyframesHandler;

package/dist/preview-server/routes/insert-jsx-element.d.ts

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