@remotion/studio 4.0.469 → 4.0.471

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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,
+        setCodeValues,
+        applyOptimistic: (prev) => (0, studio_shared_1.optimisticDeleteSequenceKeyframe)({
+            previous: prev,
+            fieldKey,
+            frame: sourceFrame,
+        }),
+        apiCall: () => (0, call_api_1.callApi)('/api/delete-keyframes', {
+            sequenceKeyframes: [
+                {
+                    fileName,
+                    nodePath,
+                    key: fieldKey,
+                    frame: sourceFrame,
+                    schema,
+                },
+            ],
+            effectKeyframes: [],
+            clientId,
+        }),
+        errorLabel: 'Could not delete keyframe',
+    });
+};
+exports.callDeleteSequenceKeyframe = callDeleteSequenceKeyframe;
+const callDeleteEffectKeyframe = ({ fileName, nodePath, effectIndex, fieldKey, sourceFrame, schema, setCodeValues, clientId, }) => {
+    return (0, save_prop_queue_1.enqueueSavePropChange)({
+        nodePath,
+        setCodeValues,
+        applyOptimistic: (prev) => (0, studio_shared_1.optimisticDeleteEffectKeyframe)({
+            previous: prev,
+            effectIndex,
+            fieldKey,
+            frame: sourceFrame,
+        }),
+        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

@@ -0,0 +1,21 @@
+import type { OverrideIdToNodePaths, TSequence } from 'remotion';
+import type { SequenceNodePathInfo } from '../../helpers/get-timeline-sequence-sort-key';
+import type { SetCodeValues } from './save-sequence-prop';
+export declare const deleteSelectedKeyframe: ({ nodePathInfo, frame, sequences, overrideIdsToNodePaths, setCodeValues, clientId, }: {
+    nodePathInfo: SequenceNodePathInfo;
+    frame: number;
+    sequences: TSequence[];
+    overrideIdsToNodePaths: OverrideIdToNodePaths;
+    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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 getSelectedKeyframeDeletion = ({ nodePathInfo, frame, sequences, overrideIdsToNodePaths, }) => {
+    var _a, _b;
+    const field = (0, parse_keyframe_field_from_node_path_1.parseKeyframeFieldFromNodePath)(nodePathInfo.auxiliaryKeys);
+    if (field === null) {
+        return null;
+    }
+    const track = (0, find_track_for_node_path_info_1.findTrackForNodePathInfo)({
+        sequences,
+        overrideIdsToNodePaths,
+        nodePathInfo,
+    });
+    const sequence = (_a = track === null || track === void 0 ? void 0 : track.sequence) !== null && _a !== void 0 ? _a : null;
+    if (!(sequence === null || sequence === void 0 ? void 0 : sequence.controls)) {
+        return null;
+    }
+    const sourceFrame = frame - ((_b = track === null || track === void 0 ? void 0 : track.keyframeDisplayOffset) !== null && _b !== void 0 ? _b : 0);
+    const nodePath = nodePathInfo.sequenceSubscriptionKey;
+    const fileName = nodePath.absolutePath;
+    if (field.type === 'effect') {
+        const effect = sequence.effects[field.effectIndex];
+        if (!effect) {
+            return null;
+        }
+        return {
+            type: 'effect',
+            fileName,
+            nodePath,
+            effectIndex: field.effectIndex,
+            fieldKey: field.fieldKey,
+            sourceFrame,
+            schema: effect.schema,
+        };
+    }
+    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.d.ts

@@ -0,0 +1,17 @@
+import type { OverrideIdToNodePaths, TSequence } from 'remotion';
+import type { SetCodeValues } from './save-sequence-prop';
+import type { TimelineSelection } from './TimelineSelection';
+export declare const deleteSelectedTimelineItem: ({ selection, sequences, overrideIdsToNodePaths, setCodeValues, clientId, }: {
+    selection: TimelineSelection;
+    sequences: TSequence[];
+    overrideIdsToNodePaths: OverrideIdToNodePaths;
+    setCodeValues: SetCodeValues;
+    clientId: string;
+}) => Promise<void> | null;
+export declare const deleteSelectedTimelineItems: ({ selections, sequences, overrideIdsToNodePaths, setCodeValues, clientId, }: {
+    selections: readonly TimelineSelection[];
+    sequences: TSequence[];
+    overrideIdsToNodePaths: OverrideIdToNodePaths;
+    setCodeValues: SetCodeValues;
+    clientId: string;
+}) => Promise<void> | null;

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

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteSelectedTimelineItems = exports.deleteSelectedTimelineItem = void 0;
+const call_api_1 = require("../call-api");
+const NotificationCenter_1 = require("../Notifications/NotificationCenter");
+const delete_selected_keyframe_1 = require("./delete-selected-keyframe");
+const confirmDeletingDuplicatedSequences = (nodePathInfos) => {
+    const duplicatedNodePathInfos = nodePathInfos.filter((nodePathInfo) => nodePathInfo.numberOfSequencesWithThisNodePath > 1);
+    if (duplicatedNodePathInfos.length === 0) {
+        return true;
+    }
+    if (duplicatedNodePathInfos.length === 1) {
+        const [nodePathInfo] = duplicatedNodePathInfos;
+        const singleDuplicatedSequenceMessage = 'This sequence is programmatically duplicated ' +
+            nodePathInfo.numberOfSequencesWithThisNodePath +
+            ' times in the code. Deleting removes all instances. Continue?';
+        // eslint-disable-next-line no-alert -- native confirm before deleting all instances of a duplicated sequence
+        return window.confirm(singleDuplicatedSequenceMessage);
+    }
+    const multipleDuplicatedSequencesMessage = duplicatedNodePathInfos.length +
+        ' selected sequences are programmatically duplicated in the code. Deleting removes all instances. Continue?';
+    // eslint-disable-next-line no-alert -- native confirm before deleting all instances of duplicated sequences
+    return window.confirm(multipleDuplicatedSequencesMessage);
+};
+const deleteSequences = (nodePathInfos) => {
+    if (!confirmDeletingDuplicatedSequences(nodePathInfos)) {
+        return Promise.resolve();
+    }
+    return (0, call_api_1.callApi)('/api/delete-jsx-node', {
+        nodes: nodePathInfos.map((nodePathInfo) => {
+            const nodePath = nodePathInfo.sequenceSubscriptionKey;
+            return {
+                fileName: nodePath.absolutePath,
+                nodePath: nodePath.nodePath,
+            };
+        }),
+    })
+        .then((result) => {
+        if (result.success) {
+            (0, NotificationCenter_1.showNotification)(nodePathInfos.length === 1
+                ? 'Removed sequence from source file'
+                : 'Removed sequences from source files', 2000);
+        }
+        else {
+            (0, NotificationCenter_1.showNotification)(result.reason, 4000);
+        }
+    })
+        .catch((err) => {
+        (0, NotificationCenter_1.showNotification)(err.message, 4000);
+    });
+};
+const deleteEffects = (effects) => {
+    if (effects.length === 0) {
+        return Promise.resolve();
+    }
+    return (0, call_api_1.callApi)('/api/delete-effect', effects.map((effect) => {
+        const nodePath = effect.nodePathInfo.sequenceSubscriptionKey;
+        return effect.type === 'single-effect'
+            ? {
+                type: 'single-effect',
+                fileName: nodePath.absolutePath,
+                sequenceNodePath: nodePath,
+                effectIndex: effect.effectIndex,
+            }
+            : {
+                type: 'all-effects',
+                fileName: nodePath.absolutePath,
+                sequenceNodePath: nodePath,
+            };
+    }))
+        .then((result) => {
+        if (result.success) {
+            const singleEffect = effects[0];
+            (0, NotificationCenter_1.showNotification)(effects.length === 1 && (singleEffect === null || singleEffect === void 0 ? void 0 : singleEffect.type) === 'single-effect'
+                ? 'Removed effect from source file'
+                : effects.length === 1
+                    ? 'Removed effects from source file'
+                    : 'Removed effects from source files', 2000);
+        }
+        else {
+            (0, NotificationCenter_1.showNotification)(result.reason, 4000);
+        }
+    })
+        .catch((err) => {
+        (0, NotificationCenter_1.showNotification)(err.message, 4000);
+    });
+};
+const deleteSelectedTimelineItem = ({ selection, sequences, overrideIdsToNodePaths, setCodeValues, clientId, }) => {
+    if (selection.type === 'keyframe') {
+        return (0, delete_selected_keyframe_1.deleteSelectedKeyframe)({
+            nodePathInfo: selection.nodePathInfo,
+            frame: selection.frame,
+            sequences,
+            overrideIdsToNodePaths,
+            setCodeValues,
+            clientId,
+        });
+    }
+    switch (selection.type) {
+        case 'sequence':
+            return deleteSequences([selection.nodePathInfo]);
+        case 'sequence-effect':
+            return deleteEffects([
+                {
+                    type: 'single-effect',
+                    nodePathInfo: selection.nodePathInfo,
+                    effectIndex: selection.i,
+                },
+            ]);
+        case 'sequence-prop':
+        case 'sequence-effect-prop':
+            return null;
+        case 'sequence-all-effects':
+            return deleteEffects([
+                { type: 'all-effects', nodePathInfo: selection.nodePathInfo },
+            ]);
+        default:
+            throw new Error(`Unexpected timeline selection type: ${selection}`);
+    }
+};
+exports.deleteSelectedTimelineItem = deleteSelectedTimelineItem;
+const isSequenceRowSelection = (selection) => selection.type === 'sequence';
+const isSequenceEffectSelection = (selection) => selection.type === 'sequence-effect';
+const isSequenceAllEffectsSelection = (selection) => selection.type === 'sequence-all-effects';
+const isKeyframeSelection = (selection) => selection.type === 'keyframe';
+const assertTimelineSelectionsHaveSameType = (selections) => {
+    const firstSelection = selections[0];
+    if (!firstSelection) {
+        return;
+    }
+    for (const selection of selections) {
+        if (selection.type !== firstSelection.type) {
+            throw new Error(`Assertion failed: Cannot delete timeline selections of different types (${firstSelection.type}, ${selection.type})`);
+        }
+    }
+};
+const deleteSelectedTimelineItems = ({ selections, sequences, overrideIdsToNodePaths, setCodeValues, clientId, }) => {
+    const firstSelection = selections[0];
+    if (!firstSelection) {
+        return null;
+    }
+    assertTimelineSelectionsHaveSameType(selections);
+    switch (firstSelection.type) {
+        case 'sequence':
+            return deleteSequences(selections
+                .filter(isSequenceRowSelection)
+                .map((selection) => selection.nodePathInfo));
+        case 'sequence-effect':
+            return deleteEffects(selections.filter(isSequenceEffectSelection).map((selection) => ({
+                type: 'single-effect',
+                nodePathInfo: selection.nodePathInfo,
+                effectIndex: selection.i,
+            })));
+        case 'keyframe': {
+            return (0, delete_selected_keyframe_1.deleteSelectedKeyframes)({
+                keyframes: selections.filter(isKeyframeSelection).map((selection) => ({
+                    nodePathInfo: selection.nodePathInfo,
+                    frame: selection.frame,
+                })),
+                sequences,
+                overrideIdsToNodePaths,
+                setCodeValues,
+                clientId,
+            });
+        }
+        case 'sequence-prop':
+        case 'sequence-effect-prop':
+            return null;
+        case 'sequence-all-effects':
+            return deleteEffects(selections.filter(isSequenceAllEffectsSelection).map((selection) => ({
+                type: 'all-effects',
+                nodePathInfo: selection.nodePathInfo,
+            })));
+        default:
+            throw new Error(`Unexpected timeline selection type: ${firstSelection}`);
+    }
+};
+exports.deleteSelectedTimelineItems = deleteSelectedTimelineItems;

package/dist/components/Timeline/duplicate-selected-timeline-item.d.ts

@@ -0,0 +1,13 @@
+import type { SequenceNodePathInfo } from '../../helpers/get-timeline-sequence-sort-key';
+import type { TimelineSelection } from './TimelineSelection';
+export declare const duplicateSequencesFromSource: (nodePathInfos: readonly SequenceNodePathInfo[]) => Promise<void>;
+export declare const isDuplicatableSequenceRowSelection: (selection: TimelineSelection) => selection is {
+    readonly nodePathInfo: SequenceNodePathInfo;
+} & {
+    readonly type: "sequence";
+} & {
+    type: "sequence";
+};
+export declare const duplicateSelectedTimelineItems: ({ selections, }: {
+    selections: readonly TimelineSelection[];
+}) => Promise<void> | null;

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.duplicateSelectedTimelineItems = exports.isDuplicatableSequenceRowSelection = exports.duplicateSequencesFromSource = void 0;
+const call_api_1 = require("../call-api");
+const NotificationCenter_1 = require("../Notifications/NotificationCenter");
+const confirmDuplicatingProgrammaticallyDuplicatedSequences = (nodePathInfos) => {
+    if (nodePathInfos.length === 0) {
+        return true;
+    }
+    if (nodePathInfos.length === 1) {
+        const [nodePathInfo] = nodePathInfos;
+        const singleDuplicatedSequenceMessage = 'This sequence is programmatically duplicated ' +
+            nodePathInfo.numberOfSequencesWithThisNodePath +
+            ' times in the code. Duplicating inserts another copy. Continue?';
+        // eslint-disable-next-line no-alert -- native confirm before applying duplicate codemod in .map callbacks
+        return window.confirm(singleDuplicatedSequenceMessage);
+    }
+    const multipleDuplicatedSequencesMessage = nodePathInfos.length +
+        ' selected sequences are programmatically duplicated in the code. Duplicating inserts another copy of each. Continue?';
+    // eslint-disable-next-line no-alert -- native confirm before applying duplicate codemod in .map callbacks
+    return window.confirm(multipleDuplicatedSequencesMessage);
+};
+const duplicateSequence = (nodePathInfo) => {
+    const nodePath = nodePathInfo.sequenceSubscriptionKey;
+    return (0, call_api_1.callApi)('/api/duplicate-jsx-node', {
+        fileName: nodePath.absolutePath,
+        nodePath: nodePath.nodePath,
+    });
+};
+const duplicateSequencesFromSource = (nodePathInfos) => {
+    const programmaticallyDuplicated = nodePathInfos.filter((nodePathInfo) => nodePathInfo.numberOfSequencesWithThisNodePath > 1);
+    const regular = nodePathInfos.filter((nodePathInfo) => nodePathInfo.numberOfSequencesWithThisNodePath <= 1);
+    const toDuplicate = [...regular];
+    if (programmaticallyDuplicated.length === 0 ||
+        confirmDuplicatingProgrammaticallyDuplicatedSequences(programmaticallyDuplicated)) {
+        toDuplicate.push(...programmaticallyDuplicated);
+    }
+    if (toDuplicate.length === 0) {
+        return Promise.resolve();
+    }
+    return Promise.all(toDuplicate.map(duplicateSequence))
+        .then((results) => {
+        const failedResult = results.find((result) => !result.success);
+        if (failedResult && !failedResult.success) {
+            (0, NotificationCenter_1.showNotification)(failedResult.reason, 4000);
+            return;
+        }
+        (0, NotificationCenter_1.showNotification)(toDuplicate.length === 1
+            ? 'Duplicated sequence in source file'
+            : 'Duplicated sequences in source files', 2000);
+    })
+        .catch((err) => {
+        (0, NotificationCenter_1.showNotification)(err.message, 4000);
+    });
+};
+exports.duplicateSequencesFromSource = duplicateSequencesFromSource;
+const isDuplicatableSequenceRowSelection = (selection) => selection.type === 'sequence';
+exports.isDuplicatableSequenceRowSelection = isDuplicatableSequenceRowSelection;
+const duplicateSelectedTimelineItems = ({ selections, }) => {
+    const sequenceSelections = selections.filter(exports.isDuplicatableSequenceRowSelection);
+    if (sequenceSelections.length === 0) {
+        return null;
+    }
+    return (0, exports.duplicateSequencesFromSource)(sequenceSelections.map((selection) => selection.nodePathInfo));
+};
+exports.duplicateSelectedTimelineItems = duplicateSelectedTimelineItems;

package/dist/components/Timeline/find-track-for-node-path-info.d.ts

@@ -0,0 +1,7 @@
+import type { OverrideIdToNodePaths, TSequence } from 'remotion';
+import type { SequenceNodePathInfo } from '../../helpers/get-timeline-sequence-sort-key';
+export declare const findTrackForNodePathInfo: ({ sequences, overrideIdsToNodePaths, nodePathInfo, }: {
+    sequences: TSequence[];
+    overrideIdsToNodePaths: OverrideIdToNodePaths;
+    nodePathInfo: SequenceNodePathInfo;
+}) => import("../../helpers/get-timeline-sequence-sort-key").TrackWithHash | undefined;

package/dist/components/Timeline/find-track-for-node-path-info.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findTrackForNodePathInfo = void 0;
+const studio_shared_1 = require("@remotion/studio-shared");
+const calculate_timeline_1 = require("../../helpers/calculate-timeline");
+const findTrackForNodePathInfo = ({ sequences, overrideIdsToNodePaths, nodePathInfo, }) => {
+    const tracks = (0, calculate_timeline_1.calculateTimeline)({ sequences, overrideIdsToNodePaths });
+    return tracks.find((candidate) => candidate.nodePathInfo !== null &&
+        (0, studio_shared_1.stringifySequenceSubscriptionKey)(candidate.nodePathInfo.sequenceSubscriptionKey) ===
+            (0, studio_shared_1.stringifySequenceSubscriptionKey)(nodePathInfo.sequenceSubscriptionKey) &&
+        candidate.nodePathInfo.index === nodePathInfo.index);
+};
+exports.findTrackForNodePathInfo = findTrackForNodePathInfo;

package/dist/components/Timeline/get-keyframe-navigation.d.ts

@@ -0,0 +1,9 @@
+export declare const getPreviousKeyframeDisplayFrame: (keyframes: readonly {
+    frame: number;
+}[], currentDisplayFrame: number) => number | null;
+export declare const getNextKeyframeDisplayFrame: (keyframes: readonly {
+    frame: number;
+}[], currentDisplayFrame: number) => number | null;
+export declare const hasKeyframeAtSourceFrame: (keyframes: readonly {
+    frame: number;
+}[], sourceFrame: number) => boolean;

package/dist/components/Timeline/get-keyframe-navigation.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasKeyframeAtSourceFrame = exports.getNextKeyframeDisplayFrame = exports.getPreviousKeyframeDisplayFrame = void 0;
+const getPreviousKeyframeDisplayFrame = (keyframes, currentDisplayFrame) => {
+    let previous = null;
+    for (const keyframe of keyframes) {
+        if (keyframe.frame < currentDisplayFrame) {
+            previous = keyframe.frame;
+        }
+    }
+    return previous;
+};
+exports.getPreviousKeyframeDisplayFrame = getPreviousKeyframeDisplayFrame;
+const getNextKeyframeDisplayFrame = (keyframes, currentDisplayFrame) => {
+    for (const keyframe of keyframes) {
+        if (keyframe.frame > currentDisplayFrame) {
+            return keyframe.frame;
+        }
+    }
+    return null;
+};
+exports.getNextKeyframeDisplayFrame = getNextKeyframeDisplayFrame;
+const hasKeyframeAtSourceFrame = (keyframes, sourceFrame) => {
+    return keyframes.some((keyframe) => keyframe.frame === sourceFrame);
+};
+exports.hasKeyframeAtSourceFrame = hasKeyframeAtSourceFrame;

package/dist/components/Timeline/parse-keyframe-field-from-node-path.d.ts

@@ -0,0 +1,8 @@
+export declare const parseKeyframeFieldFromNodePath: (auxiliaryKeys: string[]) => {
+    readonly type: "sequence";
+    readonly fieldKey: string;
+} | {
+    readonly type: "effect";
+    readonly effectIndex: number;
+    readonly fieldKey: string;
+} | null;

package/dist/components/Timeline/parse-keyframe-field-from-node-path.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseKeyframeFieldFromNodePath = void 0;
+const parseKeyframeFieldFromNodePath = (auxiliaryKeys) => {
+    // Sequence control field: ['controls', fieldKey]
+    if (auxiliaryKeys[0] === 'controls' && auxiliaryKeys.length >= 2) {
+        return {
+            type: 'sequence',
+            fieldKey: auxiliaryKeys[1],
+        };
+    }
+    // Effect field: ['effects', effectIndex, fieldKey]
+    if (auxiliaryKeys[0] === 'effects' && auxiliaryKeys.length >= 3) {
+        const effectIndex = Number(auxiliaryKeys[1]);
+        if (!Number.isInteger(effectIndex) || effectIndex < 0) {
+            return null;
+        }
+        return {
+            type: 'effect',
+            effectIndex,
+            fieldKey: auxiliaryKeys[2],
+        };
+    }
+    return null;
+};
+exports.parseKeyframeFieldFromNodePath = parseKeyframeFieldFromNodePath;

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 {};