@remotion/studio 4.0.468 → 4.0.470

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

@@ -0,0 +1,23 @@
+import type { SequencePropsSubscriptionKey, SequenceSchema } from 'remotion';
+import type { SetCodeValues } from './save-sequence-prop';
+export declare const callAddSequenceKeyframe: ({ fileName, nodePath, fieldKey, sourceFrame, value, schema, setCodeValues, clientId, }: {
+    fileName: string;
+    nodePath: SequencePropsSubscriptionKey;
+    fieldKey: string;
+    sourceFrame: number;
+    value: unknown;
+    schema: SequenceSchema;
+    setCodeValues: SetCodeValues;
+    clientId: string;
+}) => Promise<void>;
+export declare const callAddEffectKeyframe: ({ fileName, nodePath, effectIndex, fieldKey, sourceFrame, value, schema, setCodeValues, clientId, }: {
+    fileName: string;
+    nodePath: SequencePropsSubscriptionKey;
+    effectIndex: number;
+    fieldKey: string;
+    sourceFrame: number;
+    value: unknown;
+    schema: SequenceSchema;
+    setCodeValues: SetCodeValues;
+    clientId: string;
+}) => Promise<void>;

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callAddEffectKeyframe = exports.callAddSequenceKeyframe = 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 callAddSequenceKeyframe = ({ fileName, nodePath, fieldKey, sourceFrame, value, schema, setCodeValues, clientId, }) => {
+    return (0, save_prop_queue_1.enqueueSavePropChange)({
+        nodePath,
+        setCodeValues,
+        applyOptimistic: (prev) => (0, studio_shared_1.optimisticAddSequenceKeyframe)({
+            previous: prev,
+            fieldKey,
+            frame: sourceFrame,
+            value,
+        }),
+        apiCall: () => (0, call_api_1.callApi)('/api/add-sequence-keyframe', {
+            fileName,
+            nodePath,
+            key: fieldKey,
+            frame: sourceFrame,
+            value: JSON.stringify(value),
+            schema,
+            clientId,
+        }),
+        errorLabel: 'Could not add keyframe',
+    });
+};
+exports.callAddSequenceKeyframe = callAddSequenceKeyframe;
+const callAddEffectKeyframe = ({ fileName, nodePath, effectIndex, fieldKey, sourceFrame, value, schema, setCodeValues, clientId, }) => {
+    return (0, save_prop_queue_1.enqueueSavePropChange)({
+        nodePath,
+        setCodeValues,
+        applyOptimistic: (prev) => (0, studio_shared_1.optimisticAddEffectKeyframe)({
+            previous: prev,
+            effectIndex,
+            fieldKey,
+            frame: sourceFrame,
+            value,
+        }),
+        apiCall: () => (0, call_api_1.callApi)('/api/add-effect-keyframe', {
+            fileName,
+            sequenceNodePath: nodePath,
+            effectIndex,
+            key: fieldKey,
+            frame: sourceFrame,
+            value: JSON.stringify(value),
+            schema,
+            clientId,
+        }),
+        errorLabel: 'Could not add keyframe',
+    });
+};
+exports.callAddEffectKeyframe = callAddEffectKeyframe;

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

@@ -0,0 +1,21 @@
+import type { SequencePropsSubscriptionKey, SequenceSchema } from 'remotion';
+import type { SetCodeValues } from './save-sequence-prop';
+export declare const callDeleteSequenceKeyframe: ({ fileName, nodePath, fieldKey, sourceFrame, schema, setCodeValues, clientId, }: {
+    fileName: string;
+    nodePath: SequencePropsSubscriptionKey;
+    fieldKey: string;
+    sourceFrame: number;
+    schema: SequenceSchema;
+    setCodeValues: SetCodeValues;
+    clientId: string;
+}) => Promise<void>;
+export declare const callDeleteEffectKeyframe: ({ fileName, nodePath, effectIndex, fieldKey, sourceFrame, schema, setCodeValues, clientId, }: {
+    fileName: string;
+    nodePath: SequencePropsSubscriptionKey;
+    effectIndex: number;
+    fieldKey: string;
+    sourceFrame: number;
+    schema: SequenceSchema;
+    setCodeValues: SetCodeValues;
+    clientId: string;
+}) => Promise<void>;

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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-sequence-keyframe', {
+            fileName,
+            nodePath,
+            key: fieldKey,
+            frame: sourceFrame,
+            schema,
+            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-effect-keyframe', {
+            fileName,
+            sequenceNodePath: nodePath,
+            effectIndex,
+            key: fieldKey,
+            frame: sourceFrame,
+            schema,
+            clientId,
+        }),
+        errorLabel: 'Could not delete keyframe',
+    });
+};
+exports.callDeleteEffectKeyframe = callDeleteEffectKeyframe;

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

@@ -0,0 +1,11 @@
+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;

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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, }) => {
+    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 (0, call_delete_keyframe_1.callDeleteEffectKeyframe)({
+            fileName,
+            nodePath,
+            effectIndex: field.effectIndex,
+            fieldKey: field.fieldKey,
+            sourceFrame,
+            schema: effect.schema,
+            setCodeValues,
+            clientId,
+        });
+    }
+    return (0, call_delete_keyframe_1.callDeleteSequenceKeyframe)({
+        fileName,
+        nodePath,
+        fieldKey: field.fieldKey,
+        sourceFrame,
+        schema: sequence.controls.schema,
+        setCodeValues,
+        clientId,
+    });
+};
+exports.deleteSelectedKeyframe = deleteSelectedKeyframe;

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,183 @@
+"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': {
+            const deletePromises = selections
+                .filter(isKeyframeSelection)
+                .map((selection) => (0, delete_selected_keyframe_1.deleteSelectedKeyframe)({
+                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':
+            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/get-node-keyframes.d.ts

@@ -0,0 +1,11 @@
+import { type CodeValues, type SequencePropsSubscriptionKey } from 'remotion';
+import type { TimelineTreeNode } from '../../helpers/timeline-layout';
+export declare const getNodeKeyframes: ({ node, nodePath, codeValues, keyframeDisplayOffset, }: {
+    node: TimelineTreeNode;
+    nodePath: SequencePropsSubscriptionKey;
+    codeValues: CodeValues;
+    keyframeDisplayOffset: number;
+}) => {
+    frame: number;
+    value: unknown;
+}[];

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

@@ -0,0 +1,23 @@
+"use strict";
+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, }) => {
+    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 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);
+};
+exports.getNodeKeyframes = getNodeKeyframes;

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

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

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;