@remotion/studio 4.0.470 → 4.0.472

package/dist/components/Timeline/TimelineUvCoordinateField.js

@@ -57,8 +57,7 @@ const TimelineUvCoordinateField = ({ field, propStatus, effectiveValue, onSave,
     const onXChangeEnd = (0, react_1.useCallback)((newVal) => {
         const currentY = dragY !== null && dragY !== void 0 ? dragY : codeY;
         const newTuple = [newVal, currentY];
-        if (propStatus.canUpdate &&
-            !tuplesEqual(propStatus.codeValue, newTuple)) {
+        if (!tuplesEqual(propStatus.codeValue, newTuple)) {
             onSave(newTuple).finally(() => {
                 setDragX(null);
                 onDragEnd();
@@ -70,17 +69,15 @@ const TimelineUvCoordinateField = ({ field, propStatus, effectiveValue, onSave,
         }
     }, [dragY, codeY, propStatus, onSave, onDragEnd]);
     const onXTextChange = (0, react_1.useCallback)((newVal) => {
-        if (propStatus.canUpdate) {
-            const parsed = Number(newVal);
-            if (!Number.isNaN(parsed)) {
-                const currentY = dragY !== null && dragY !== void 0 ? dragY : codeY;
-                const newTuple = [parsed, currentY];
-                if (!tuplesEqual(propStatus.codeValue, newTuple)) {
-                    setDragX(parsed);
-                    onSave(newTuple).finally(() => {
-                        setDragX(null);
-                    });
-                }
+        const parsed = Number(newVal);
+        if (!Number.isNaN(parsed)) {
+            const currentY = dragY !== null && dragY !== void 0 ? dragY : codeY;
+            const newTuple = [parsed, currentY];
+            if (!tuplesEqual(propStatus.codeValue, newTuple)) {
+                setDragX(parsed);
+                onSave(newTuple).finally(() => {
+                    setDragX(null);
+                });
             }
         }
     }, [propStatus, dragY, codeY, onSave]);
@@ -92,8 +89,7 @@ const TimelineUvCoordinateField = ({ field, propStatus, effectiveValue, onSave,
     const onYChangeEnd = (0, react_1.useCallback)((newVal) => {
         const currentX = dragX !== null && dragX !== void 0 ? dragX : codeX;
         const newTuple = [currentX, newVal];
-        if (propStatus.canUpdate &&
-            !tuplesEqual(propStatus.codeValue, newTuple)) {
+        if (!tuplesEqual(propStatus.codeValue, newTuple)) {
             onSave(newTuple).finally(() => {
                 setDragY(null);
                 onDragEnd();
@@ -105,17 +101,15 @@ const TimelineUvCoordinateField = ({ field, propStatus, effectiveValue, onSave,
         }
     }, [dragX, codeX, propStatus, onSave, onDragEnd]);
     const onYTextChange = (0, react_1.useCallback)((newVal) => {
-        if (propStatus.canUpdate) {
-            const parsed = Number(newVal);
-            if (!Number.isNaN(parsed)) {
-                const currentX = dragX !== null && dragX !== void 0 ? dragX : codeX;
-                const newTuple = [currentX, parsed];
-                if (!tuplesEqual(propStatus.codeValue, newTuple)) {
-                    setDragY(parsed);
-                    onSave(newTuple).finally(() => {
-                        setDragY(null);
-                    });
-                }
+        const parsed = Number(newVal);
+        if (!Number.isNaN(parsed)) {
+            const currentX = dragX !== null && dragX !== void 0 ? dragX : codeX;
+            const newTuple = [currentX, parsed];
+            if (!tuplesEqual(propStatus.codeValue, newTuple)) {
+                setDragY(parsed);
+                onSave(newTuple).finally(() => {
+                    setDragY(null);
+                });
             }
         }
     }, [propStatus, onSave, dragX, codeX]);

package/dist/components/Timeline/call-add-keyframe.js

@@ -13,6 +13,7 @@ const callAddSequenceKeyframe = ({ fileName, nodePath, fieldKey, sourceFrame, va
             fieldKey,
             frame: sourceFrame,
             value,
+            schema,
         }),
         apiCall: () => (0, call_api_1.callApi)('/api/add-sequence-keyframe', {
             fileName,
@@ -37,6 +38,7 @@ const callAddEffectKeyframe = ({ fileName, nodePath, effectIndex, fieldKey, sour
             fieldKey,
             frame: sourceFrame,
             value,
+            schema,
         }),
         apiCall: () => (0, call_api_1.callApi)('/api/add-effect-keyframe', {
             fileName,

package/dist/components/Timeline/call-delete-keyframe.d.ts

@@ -1,5 +1,15 @@
 import type { SequencePropsSubscriptionKey, SequenceSchema } from 'remotion';
 import type { SetCodeValues } from './save-sequence-prop';
+export type DeleteSequenceKeyframeChange = {
+    fileName: string;
+    nodePath: SequencePropsSubscriptionKey;
+    fieldKey: string;
+    sourceFrame: number;
+    schema: SequenceSchema;
+};
+export type DeleteEffectKeyframeChange = DeleteSequenceKeyframeChange & {
+    effectIndex: number;
+};
 export declare const callDeleteSequenceKeyframe: ({ fileName, nodePath, fieldKey, sourceFrame, schema, setCodeValues, clientId, }: {
     fileName: string;
     nodePath: SequencePropsSubscriptionKey;
@@ -19,3 +29,9 @@ export declare const callDeleteEffectKeyframe: ({ fileName, nodePath, effectInde
     setCodeValues: SetCodeValues;
     clientId: string;
 }) => Promise<void>;
+export declare const callDeleteKeyframes: ({ sequenceKeyframes, effectKeyframes, setCodeValues, clientId, }: {
+    sequenceKeyframes: DeleteSequenceKeyframeChange[];
+    effectKeyframes: DeleteEffectKeyframeChange[];
+    setCodeValues: SetCodeValues;
+    clientId: string;
+}) => Promise<void>;

package/dist/components/Timeline/call-delete-keyframe.js

@@ -1,9 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.callDeleteEffectKeyframe = exports.callDeleteSequenceKeyframe = void 0;
+exports.callDeleteKeyframes = exports.callDeleteEffectKeyframe = exports.callDeleteSequenceKeyframe = void 0;
 const studio_shared_1 = require("@remotion/studio-shared");
 const call_api_1 = require("../call-api");
 const save_prop_queue_1 = require("./save-prop-queue");
+const groupByNodePath = (keyframes) => {
+    var _a;
+    const groups = new Map();
+    for (const keyframe of keyframes) {
+        const key = JSON.stringify(keyframe.nodePath);
+        const group = (_a = groups.get(key)) !== null && _a !== void 0 ? _a : [];
+        group.push(keyframe);
+        groups.set(key, group);
+    }
+    return [...groups.values()];
+};
 const callDeleteSequenceKeyframe = ({ fileName, nodePath, fieldKey, sourceFrame, schema, setCodeValues, clientId, }) => {
     return (0, save_prop_queue_1.enqueueSavePropChange)({
         nodePath,
@@ -13,12 +24,17 @@ const callDeleteSequenceKeyframe = ({ fileName, nodePath, fieldKey, sourceFrame,
             fieldKey,
             frame: sourceFrame,
         }),
-        apiCall: () => (0, call_api_1.callApi)('/api/delete-sequence-keyframe', {
-            fileName,
-            nodePath,
-            key: fieldKey,
-            frame: sourceFrame,
-            schema,
+        apiCall: () => (0, call_api_1.callApi)('/api/delete-keyframes', {
+            sequenceKeyframes: [
+                {
+                    fileName,
+                    nodePath,
+                    key: fieldKey,
+                    frame: sourceFrame,
+                    schema,
+                },
+            ],
+            effectKeyframes: [],
             clientId,
         }),
         errorLabel: 'Could not delete keyframe',
@@ -35,16 +51,72 @@ const callDeleteEffectKeyframe = ({ fileName, nodePath, effectIndex, fieldKey, s
             fieldKey,
             frame: sourceFrame,
         }),
-        apiCall: () => (0, call_api_1.callApi)('/api/delete-effect-keyframe', {
-            fileName,
-            sequenceNodePath: nodePath,
-            effectIndex,
-            key: fieldKey,
-            frame: sourceFrame,
-            schema,
+        apiCall: () => (0, call_api_1.callApi)('/api/delete-keyframes', {
+            sequenceKeyframes: [],
+            effectKeyframes: [
+                {
+                    fileName,
+                    sequenceNodePath: nodePath,
+                    effectIndex,
+                    key: fieldKey,
+                    frame: sourceFrame,
+                    schema,
+                },
+            ],
             clientId,
         }),
         errorLabel: 'Could not delete keyframe',
     });
 };
 exports.callDeleteEffectKeyframe = callDeleteEffectKeyframe;
+const callDeleteKeyframes = ({ sequenceKeyframes, effectKeyframes, setCodeValues, clientId, }) => {
+    if (sequenceKeyframes.length === 0 && effectKeyframes.length === 0) {
+        return Promise.resolve();
+    }
+    for (const keyframes of groupByNodePath(sequenceKeyframes)) {
+        const [firstKeyframe] = keyframes;
+        if (!firstKeyframe) {
+            continue;
+        }
+        setCodeValues(firstKeyframe.nodePath, (prev) => (0, studio_shared_1.optimisticDeleteSequenceKeyframes)({
+            previous: prev,
+            keyframes: keyframes.map((keyframe) => ({
+                fieldKey: keyframe.fieldKey,
+                frame: keyframe.sourceFrame,
+            })),
+        }));
+    }
+    for (const keyframes of groupByNodePath(effectKeyframes)) {
+        const [firstKeyframe] = keyframes;
+        if (!firstKeyframe) {
+            continue;
+        }
+        setCodeValues(firstKeyframe.nodePath, (prev) => (0, studio_shared_1.optimisticDeleteEffectKeyframes)({
+            previous: prev,
+            keyframes: keyframes.map((keyframe) => ({
+                effectIndex: keyframe.effectIndex,
+                fieldKey: keyframe.fieldKey,
+                frame: keyframe.sourceFrame,
+            })),
+        }));
+    }
+    return (0, call_api_1.callApi)('/api/delete-keyframes', {
+        sequenceKeyframes: sequenceKeyframes.map((keyframe) => ({
+            fileName: keyframe.fileName,
+            nodePath: keyframe.nodePath,
+            key: keyframe.fieldKey,
+            frame: keyframe.sourceFrame,
+            schema: keyframe.schema,
+        })),
+        effectKeyframes: effectKeyframes.map((keyframe) => ({
+            fileName: keyframe.fileName,
+            sequenceNodePath: keyframe.nodePath,
+            effectIndex: keyframe.effectIndex,
+            key: keyframe.fieldKey,
+            frame: keyframe.sourceFrame,
+            schema: keyframe.schema,
+        })),
+        clientId,
+    }).then(() => undefined);
+};
+exports.callDeleteKeyframes = callDeleteKeyframes;

package/dist/components/Timeline/delete-selected-keyframe.d.ts

@@ -9,3 +9,13 @@ export declare const deleteSelectedKeyframe: ({ nodePathInfo, frame, sequences,
     setCodeValues: SetCodeValues;
     clientId: string;
 }) => Promise<void> | null;
+export declare const deleteSelectedKeyframes: ({ keyframes, sequences, overrideIdsToNodePaths, setCodeValues, clientId, }: {
+    keyframes: {
+        nodePathInfo: SequenceNodePathInfo;
+        frame: number;
+    }[];
+    sequences: TSequence[];
+    overrideIdsToNodePaths: OverrideIdToNodePaths;
+    setCodeValues: SetCodeValues;
+    clientId: string;
+}) => Promise<void> | null;

package/dist/components/Timeline/delete-selected-keyframe.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteSelectedKeyframe = void 0;
+exports.deleteSelectedKeyframes = exports.deleteSelectedKeyframe = void 0;
 const call_delete_keyframe_1 = require("./call-delete-keyframe");
 const find_track_for_node_path_info_1 = require("./find-track-for-node-path-info");
 const parse_keyframe_field_from_node_path_1 = require("./parse-keyframe-field-from-node-path");
-const deleteSelectedKeyframe = ({ nodePathInfo, frame, sequences, overrideIdsToNodePaths, setCodeValues, clientId, }) => {
+const getSelectedKeyframeDeletion = ({ nodePathInfo, frame, sequences, overrideIdsToNodePaths, }) => {
     var _a, _b;
     const field = (0, parse_keyframe_field_from_node_path_1.parseKeyframeFieldFromNodePath)(nodePathInfo.auxiliaryKeys);
     if (field === null) {
@@ -27,25 +27,66 @@ const deleteSelectedKeyframe = ({ nodePathInfo, frame, sequences, overrideIdsToN
         if (!effect) {
             return null;
         }
-        return (0, call_delete_keyframe_1.callDeleteEffectKeyframe)({
+        return {
+            type: 'effect',
             fileName,
             nodePath,
             effectIndex: field.effectIndex,
             fieldKey: field.fieldKey,
             sourceFrame,
             schema: effect.schema,
-            setCodeValues,
-            clientId,
-        });
+        };
     }
-    return (0, call_delete_keyframe_1.callDeleteSequenceKeyframe)({
+    return {
+        type: 'sequence',
         fileName,
         nodePath,
         fieldKey: field.fieldKey,
         sourceFrame,
         schema: sequence.controls.schema,
+    };
+};
+const deleteSelectedKeyframe = ({ nodePathInfo, frame, sequences, overrideIdsToNodePaths, setCodeValues, clientId, }) => {
+    const deletion = getSelectedKeyframeDeletion({
+        nodePathInfo,
+        frame,
+        sequences,
+        overrideIdsToNodePaths,
+    });
+    if (deletion === null) {
+        return null;
+    }
+    if (deletion.type === 'effect') {
+        return (0, call_delete_keyframe_1.callDeleteEffectKeyframe)({
+            ...deletion,
+            setCodeValues,
+            clientId,
+        });
+    }
+    return (0, call_delete_keyframe_1.callDeleteSequenceKeyframe)({
+        ...deletion,
         setCodeValues,
         clientId,
     });
 };
 exports.deleteSelectedKeyframe = deleteSelectedKeyframe;
+const deleteSelectedKeyframes = ({ keyframes, sequences, overrideIdsToNodePaths, setCodeValues, clientId, }) => {
+    const deletions = keyframes
+        .map((keyframe) => getSelectedKeyframeDeletion({
+        nodePathInfo: keyframe.nodePathInfo,
+        frame: keyframe.frame,
+        sequences,
+        overrideIdsToNodePaths,
+    }))
+        .filter((deletion) => deletion !== null);
+    if (deletions.length === 0) {
+        return null;
+    }
+    return (0, call_delete_keyframe_1.callDeleteKeyframes)({
+        sequenceKeyframes: deletions.filter((deletion) => deletion.type === 'sequence'),
+        effectKeyframes: deletions.filter((deletion) => deletion.type === 'effect'),
+        setCodeValues,
+        clientId,
+    });
+};
+exports.deleteSelectedKeyframes = deleteSelectedKeyframes;

package/dist/components/Timeline/delete-selected-timeline-item.js

@@ -152,21 +152,16 @@ const deleteSelectedTimelineItems = ({ selections, sequences, overrideIdsToNodeP
                 effectIndex: selection.i,
             })));
         case 'keyframe': {
-            const deletePromises = selections
-                .filter(isKeyframeSelection)
-                .map((selection) => (0, delete_selected_keyframe_1.deleteSelectedKeyframe)({
-                nodePathInfo: selection.nodePathInfo,
-                frame: selection.frame,
+            return (0, delete_selected_keyframe_1.deleteSelectedKeyframes)({
+                keyframes: selections.filter(isKeyframeSelection).map((selection) => ({
+                    nodePathInfo: selection.nodePathInfo,
+                    frame: selection.frame,
+                })),
                 sequences,
                 overrideIdsToNodePaths,
                 setCodeValues,
                 clientId,
-            }))
-                .filter((promise) => promise !== null);
-            if (deletePromises.length === 0) {
-                return null;
-            }
-            return Promise.all(deletePromises).then(() => undefined);
+            });
         }
         case 'sequence-prop':
         case 'sequence-effect-prop':

package/dist/components/Timeline/get-node-keyframes.d.ts

@@ -1,10 +1,13 @@
-import { type CodeValues, type SequencePropsSubscriptionKey } from 'remotion';
+import { type CodeValues, type GetDragOverrides, type GetEffectDragOverrides, type SequencePropsSubscriptionKey } from 'remotion';
 import type { TimelineTreeNode } from '../../helpers/timeline-layout';
-export declare const getNodeKeyframes: ({ node, nodePath, codeValues, keyframeDisplayOffset, }: {
+export declare const getNodeKeyframes: ({ node, nodePath, codeValues, keyframeDisplayOffset, getDragOverrides, getEffectDragOverrides, timelinePosition, }: {
     node: TimelineTreeNode;
     nodePath: SequencePropsSubscriptionKey;
     codeValues: CodeValues;
     keyframeDisplayOffset: number;
+    getDragOverrides: GetDragOverrides;
+    getEffectDragOverrides: GetEffectDragOverrides;
+    timelinePosition: number;
 }) => {
     frame: number;
     value: unknown;

package/dist/components/Timeline/get-node-keyframes.js

@@ -3,21 +3,54 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNodeKeyframes = void 0;
 const remotion_1 = require("remotion");
 const get_timeline_keyframes_1 = require("./get-timeline-keyframes");
-const getNodeKeyframes = ({ node, nodePath, codeValues, keyframeDisplayOffset, }) => {
+const hasOverride = (overrides, key) => Object.prototype.hasOwnProperty.call(overrides, key);
+const withDragOverrideKeyframe = ({ propStatus, keyframeDisplayOffset, timelinePosition, dragOverrideValue, hasDragOverride, }) => {
+    if ((dragOverrideValue === null || dragOverrideValue === void 0 ? void 0 : dragOverrideValue.type) === 'keyframed') {
+        return (0, get_timeline_keyframes_1.getTimelineKeyframes)(dragOverrideValue.status, keyframeDisplayOffset);
+    }
+    const keyframes = (0, get_timeline_keyframes_1.getTimelineKeyframes)(propStatus, keyframeDisplayOffset);
+    if (!hasDragOverride || (propStatus === null || propStatus === void 0 ? void 0 : propStatus.status) !== 'keyframed') {
+        return keyframes;
+    }
+    const dragKeyframe = {
+        frame: timelinePosition,
+        value: dragOverrideValue === null || dragOverrideValue === void 0 ? void 0 : dragOverrideValue.value,
+    };
+    const existingIndex = keyframes.findIndex((keyframe) => keyframe.frame === timelinePosition);
+    if (existingIndex !== -1) {
+        return keyframes.map((keyframe, index) => index === existingIndex ? dragKeyframe : keyframe);
+    }
+    return [...keyframes, dragKeyframe].sort((first, second) => first.frame - second.frame);
+};
+const getNodeKeyframes = ({ node, nodePath, codeValues, keyframeDisplayOffset, getDragOverrides, getEffectDragOverrides, timelinePosition, }) => {
     var _a, _b;
     if (node.kind !== 'field' || node.field === null) {
         return [];
     }
     if (node.field.kind === 'sequence-field') {
-        return (0, get_timeline_keyframes_1.getTimelineKeyframes)((_a = remotion_1.Internals.getCodeValuesCtx(codeValues, nodePath)) === null || _a === void 0 ? void 0 : _a[node.field.key], keyframeDisplayOffset);
+        const dragOverrides = getDragOverrides(nodePath);
+        return withDragOverrideKeyframe({
+            propStatus: (_a = remotion_1.Internals.getCodeValuesCtx(codeValues, nodePath)) === null || _a === void 0 ? void 0 : _a[node.field.key],
+            keyframeDisplayOffset,
+            timelinePosition,
+            dragOverrideValue: dragOverrides[node.field.key],
+            hasDragOverride: hasOverride(dragOverrides, node.field.key),
+        });
     }
     const effectStatus = remotion_1.Internals.getEffectCodeValuesCtx({
         codeValues,
         nodePath,
         effectIndex: node.field.effectIndex,
     });
-    return (0, get_timeline_keyframes_1.getTimelineKeyframes)(effectStatus.type === 'can-update-effect'
-        ? (_b = effectStatus.props) === null || _b === void 0 ? void 0 : _b[node.field.key]
-        : null, keyframeDisplayOffset);
+    const effectDragOverrides = getEffectDragOverrides(nodePath, node.field.effectIndex);
+    return withDragOverrideKeyframe({
+        propStatus: effectStatus.type === 'can-update-effect'
+            ? (_b = effectStatus.props) === null || _b === void 0 ? void 0 : _b[node.field.key]
+            : null,
+        keyframeDisplayOffset,
+        timelinePosition,
+        dragOverrideValue: effectDragOverrides[node.field.key],
+        hasDragOverride: hasOverride(effectDragOverrides, node.field.key),
+    });
 };
 exports.getNodeKeyframes = getNodeKeyframes;

package/dist/components/Timeline/get-timeline-keyframes.js

@@ -2,17 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTimelineKeyframes = exports.getComputedStatusLabel = void 0;
 const getComputedStatusLabel = (propStatus) => {
-    if (propStatus.reason === 'computed') {
+    if (propStatus.status === 'computed') {
         return 'computed';
     }
-    return 'keyframed';
+    throw new Error(`Unsupported prop status: ${propStatus.status}`);
 };
 exports.getComputedStatusLabel = getComputedStatusLabel;
 const getTimelineKeyframes = (propStatus, keyframeDisplayOffset = 0) => {
-    if (!propStatus || propStatus.canUpdate) {
+    if (!propStatus) {
         return [];
     }
-    if (propStatus.reason === 'computed') {
+    if (propStatus.status !== 'keyframed') {
         return [];
     }
     const { keyframes } = propStatus;

package/dist/components/Timeline/reset-selected-timeline-props.d.ts

@@ -0,0 +1,38 @@
+import type { CodeValues, OverrideIdToNodePaths, SequencePropsSubscriptionKey, SequenceSchema, TSequence } from 'remotion';
+import type { SetCodeValues } from './save-sequence-prop';
+import type { TimelineSelection } from './TimelineSelection';
+type SequencePropResetTarget = {
+    readonly type: 'sequence-prop';
+    readonly fileName: string;
+    readonly nodePath: SequencePropsSubscriptionKey;
+    readonly fieldKey: string;
+    readonly value: unknown;
+    readonly defaultValue: string | null;
+    readonly schema: SequenceSchema;
+};
+type EffectPropResetTarget = {
+    readonly type: 'effect-prop';
+    readonly fileName: string;
+    readonly nodePath: SequencePropsSubscriptionKey;
+    readonly effectIndex: number;
+    readonly fieldKey: string;
+    readonly value: unknown;
+    readonly defaultValue: string | null;
+    readonly schema: SequenceSchema;
+};
+type TimelinePropResetTarget = SequencePropResetTarget | EffectPropResetTarget;
+export declare const getTimelinePropResetTargets: ({ selections, sequences, overrideIdsToNodePaths, codeValues, }: {
+    readonly selections: readonly TimelineSelection[];
+    readonly sequences: TSequence[];
+    readonly overrideIdsToNodePaths: OverrideIdToNodePaths;
+    readonly codeValues: CodeValues;
+}) => TimelinePropResetTarget[] | null;
+export declare const resetSelectedTimelineProps: ({ selections, sequences, overrideIdsToNodePaths, codeValues, setCodeValues, clientId, }: {
+    readonly selections: readonly TimelineSelection[];
+    readonly sequences: TSequence[];
+    readonly overrideIdsToNodePaths: OverrideIdToNodePaths;
+    readonly codeValues: CodeValues;
+    readonly setCodeValues: SetCodeValues;
+    readonly clientId: string;
+}) => Promise<void> | null;
+export {};

package/dist/components/Timeline/reset-selected-timeline-props.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetSelectedTimelineProps = exports.getTimelinePropResetTargets = void 0;
+const remotion_1 = require("remotion");
+const find_track_for_node_path_info_1 = require("./find-track-for-node-path-info");
+const save_effect_prop_1 = require("./save-effect-prop");
+const save_sequence_prop_1 = require("./save-sequence-prop");
+const isPropResetSelection = (selection) => selection.type === 'sequence-prop' ||
+    selection.type === 'sequence-effect-prop';
+const isVisibleFieldSchema = (fieldSchema) => fieldSchema !== undefined && fieldSchema.type !== 'hidden';
+const isNonDefaultCodeValue = ({ codeValue, defaultValue, }) => JSON.stringify(codeValue !== null && codeValue !== void 0 ? codeValue : defaultValue) !== JSON.stringify(defaultValue);
+const isResettablePropStatus = ({ propStatus, defaultValue, }) => {
+    if (!propStatus || propStatus.status === 'computed') {
+        return false;
+    }
+    if (defaultValue === undefined) {
+        return false;
+    }
+    if (propStatus.status === 'keyframed') {
+        return true;
+    }
+    return isNonDefaultCodeValue({
+        codeValue: propStatus.codeValue,
+        defaultValue,
+    });
+};
+const getDefaultValue = (fieldSchema) => fieldSchema.default !== undefined
+    ? JSON.stringify(fieldSchema.default)
+    : null;
+const getTimelinePropResetTargets = ({ selections, sequences, overrideIdsToNodePaths, codeValues, }) => {
+    var _a;
+    var _b;
+    const firstSelection = selections[0];
+    if (!firstSelection || !isPropResetSelection(firstSelection)) {
+        return null;
+    }
+    const resetTargets = [];
+    for (const selection of selections) {
+        if (!isPropResetSelection(selection)) {
+            throw new Error(`Assertion failed: Cannot reset timeline selections of different types (${firstSelection.type}, ${selection.type})`);
+        }
+        const track = (0, find_track_for_node_path_info_1.findTrackForNodePathInfo)({
+            sequences,
+            overrideIdsToNodePaths,
+            nodePathInfo: selection.nodePathInfo,
+        });
+        const sequence = (_b = track === null || track === void 0 ? void 0 : track.sequence) !== null && _b !== void 0 ? _b : null;
+        if (!sequence) {
+            continue;
+        }
+        const nodePath = selection.nodePathInfo.sequenceSubscriptionKey;
+        if (selection.type === 'sequence-prop') {
+            if (!sequence.controls) {
+                continue;
+            }
+            const sequenceFieldSchema = sequence.controls.schema[selection.key];
+            const sequencePropStatus = (_a = remotion_1.Internals.getCodeValuesCtx(codeValues, nodePath)) === null || _a === void 0 ? void 0 : _a[selection.key];
+            if (!isVisibleFieldSchema(sequenceFieldSchema) ||
+                !isResettablePropStatus({
+                    propStatus: sequencePropStatus,
+                    defaultValue: sequenceFieldSchema.default,
+                })) {
+                continue;
+            }
+            resetTargets.push({
+                type: 'sequence-prop',
+                fileName: nodePath.absolutePath,
+                nodePath,
+                fieldKey: selection.key,
+                value: sequenceFieldSchema.default,
+                defaultValue: getDefaultValue(sequenceFieldSchema),
+                schema: sequence.controls.schema,
+            });
+            continue;
+        }
+        const effect = sequence.effects[selection.i];
+        const fieldSchema = effect === null || effect === void 0 ? void 0 : effect.schema[selection.key];
+        const effectStatus = remotion_1.Internals.getEffectCodeValuesCtx({
+            codeValues,
+            nodePath,
+            effectIndex: selection.i,
+        });
+        const propStatus = effectStatus.type === 'can-update-effect'
+            ? effectStatus.props[selection.key]
+            : null;
+        if (!effect ||
+            !isVisibleFieldSchema(fieldSchema) ||
+            !isResettablePropStatus({
+                propStatus,
+                defaultValue: fieldSchema.default,
+            })) {
+            continue;
+        }
+        resetTargets.push({
+            type: 'effect-prop',
+            fileName: nodePath.absolutePath,
+            nodePath,
+            effectIndex: selection.i,
+            fieldKey: selection.key,
+            value: fieldSchema.default,
+            defaultValue: getDefaultValue(fieldSchema),
+            schema: effect.schema,
+        });
+    }
+    return resetTargets;
+};
+exports.getTimelinePropResetTargets = getTimelinePropResetTargets;
+const resetSelectedTimelineProps = ({ selections, sequences, overrideIdsToNodePaths, codeValues, setCodeValues, clientId, }) => {
+    const resetTargets = (0, exports.getTimelinePropResetTargets)({
+        selections,
+        sequences,
+        overrideIdsToNodePaths,
+        codeValues,
+    });
+    if (resetTargets === null || resetTargets.length === 0) {
+        return null;
+    }
+    const sequencePropTargets = resetTargets.filter((target) => target.type === 'sequence-prop');
+    const effectPropTargets = resetTargets.filter((target) => target.type === 'effect-prop');
+    const resetPromises = [];
+    if (sequencePropTargets.length > 0) {
+        resetPromises.push((0, save_sequence_prop_1.saveSequenceProps)({
+            changes: sequencePropTargets.map((target) => ({
+                fileName: target.fileName,
+                nodePath: target.nodePath,
+                fieldKey: target.fieldKey,
+                value: target.value,
+                defaultValue: target.defaultValue,
+                schema: target.schema,
+            })),
+            setCodeValues,
+            clientId,
+            undoLabel: sequencePropTargets.length > 1
+                ? 'Reset selected sequence props'
+                : null,
+            redoLabel: sequencePropTargets.length > 1
+                ? 'Reapply selected sequence props'
+                : null,
+        }));
+    }
+    for (const target of effectPropTargets) {
+        resetPromises.push((0, save_effect_prop_1.saveEffectProp)({
+            fileName: target.fileName,
+            nodePath: target.nodePath,
+            effectIndex: target.effectIndex,
+            fieldKey: target.fieldKey,
+            value: target.value,
+            defaultValue: target.defaultValue,
+            schema: target.schema,
+            setCodeValues,
+            clientId,
+        }));
+    }
+    return Promise.all(resetPromises).then(() => undefined);
+};
+exports.resetSelectedTimelineProps = resetSelectedTimelineProps;