@remotion/cli 4.0.0-lambda.3 → 4.0.0-newpaths.13

package/dist/editor/components/Timeline/TimelineTimeIndicators.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimelineTimeIndicators = exports.TimelineTimePadding = exports.TimelineTimePlaceholders = exports.TIMELINE_TIME_INDICATOR_HEIGHT = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const player_1 = require("@remotion/player");
+const react_1 = require("react");
+const remotion_1 = require("remotion");
+const colors_1 = require("../../helpers/colors");
+const timeline_layout_1 = require("../../helpers/timeline-layout");
+const render_frame_1 = require("../../state/render-frame");
+const TimeValue_1 = require("../TimeValue");
+const timeline_refs_1 = require("./timeline-refs");
+const timeline_scroll_logic_1 = require("./timeline-scroll-logic");
+const TimelineListItem_1 = require("./TimelineListItem");
+exports.TIMELINE_TIME_INDICATOR_HEIGHT = 30;
+const container = {
+    height: exports.TIMELINE_TIME_INDICATOR_HEIGHT - 4,
+    boxShadow: `0 0 4px ${colors_1.TIMELINE_BACKGROUND}`,
+    position: 'absolute',
+    backgroundColor: colors_1.TIMELINE_BACKGROUND,
+    top: 0,
+    left: 0,
+};
+const tick = {
+    width: 1,
+    backgroundColor: 'rgba(255, 255, 255, 0.15)',
+    height: 20,
+    position: 'absolute',
+};
+const secondTick = {
+    ...tick,
+    height: 15,
+};
+const tickLabel = {
+    fontSize: 12,
+    marginLeft: 8,
+    marginTop: 7,
+    color: colors_1.LIGHT_TEXT,
+};
+const timeValue = {
+    height: exports.TIMELINE_TIME_INDICATOR_HEIGHT,
+    position: 'absolute',
+    top: 0,
+    width: '100%',
+    paddingLeft: TimelineListItem_1.TOTAL_TIMELINE_LAYER_LEFT_PADDING,
+    boxShadow: `0 0 20px ${colors_1.BACKGROUND}`,
+    display: 'flex',
+    alignItems: 'center',
+    background: colors_1.BACKGROUND,
+};
+const TimelineTimePlaceholders = () => {
+    const ref = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => {
+        const currentRef = ref.current;
+        if (!currentRef) {
+            return;
+        }
+        const { current } = timeline_refs_1.timelineVerticalScroll;
+        if (!current) {
+            return;
+        }
+        const onScroll = () => {
+            currentRef.style.top = current.scrollTop + 'px';
+        };
+        current.addEventListener('scroll', onScroll);
+        return () => {
+            current.removeEventListener('scroll', onScroll);
+        };
+    }, []);
+    return ((0, jsx_runtime_1.jsx)("div", { ref: ref, style: timeValue, children: (0, jsx_runtime_1.jsx)(TimeValue_1.TimeValue, {}) }));
+};
+exports.TimelineTimePlaceholders = TimelineTimePlaceholders;
+const TimelineTimePadding = () => {
+    return ((0, jsx_runtime_1.jsx)("div", { style: {
+            height: exports.TIMELINE_TIME_INDICATOR_HEIGHT,
+        } }));
+};
+exports.TimelineTimePadding = TimelineTimePadding;
+const TimelineTimeIndicators = () => {
+    var _a;
+    const size = player_1.PlayerInternals.useElementSize(timeline_refs_1.sliderAreaRef, {
+        triggerOnWindowResize: false,
+        shouldApplyCssTransforms: true,
+    });
+    const video = remotion_1.Internals.useVideo();
+    const windowWidth = (_a = size === null || size === void 0 ? void 0 : size.width) !== null && _a !== void 0 ? _a : 0;
+    const ref = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => {
+        const currentRef = ref.current;
+        if (!currentRef) {
+            return;
+        }
+        const { current } = timeline_refs_1.timelineVerticalScroll;
+        if (!current) {
+            return;
+        }
+        const onScroll = () => {
+            currentRef.style.top = current.scrollTop + 'px';
+        };
+        current.addEventListener('scroll', onScroll);
+        return () => {
+            current.removeEventListener('scroll', onScroll);
+        };
+    }, []);
+    const style = (0, react_1.useMemo)(() => {
+        return {
+            ...container,
+            width: windowWidth,
+            overflow: 'hidden',
+        };
+    }, [windowWidth]);
+    const ticks = (0, react_1.useMemo)(() => {
+        if (!video) {
+            return [];
+        }
+        const frameInterval = (0, timeline_scroll_logic_1.getFrameIncrementFromWidth)(video.durationInFrames, windowWidth);
+        const MIN_SPACING_BETWEEN_TICKS_PX = 5;
+        const seconds = Math.floor(video.durationInFrames / video.fps);
+        const secondMarkerEveryNth = Math.ceil((MIN_SPACING_BETWEEN_TICKS_PX * video.fps) / (frameInterval * video.fps));
+        const frameMarkerEveryNth = Math.ceil(MIN_SPACING_BETWEEN_TICKS_PX / frameInterval);
+        // Big ticks showing for every second
+        const secondTicks = new Array(seconds)
+            .fill(true)
+            .map((_, index) => {
+            return {
+                frame: index * video.fps,
+                style: {
+                    ...secondTick,
+                    left: frameInterval * index * video.fps + timeline_layout_1.TIMELINE_PADDING,
+                },
+                showTime: index > 0,
+            };
+        })
+            .filter((_, idx) => idx % secondMarkerEveryNth === 0);
+        const frameTicks = new Array(video.durationInFrames)
+            .fill(true)
+            .map((_, index) => {
+            return {
+                frame: index,
+                style: {
+                    ...tick,
+                    left: frameInterval * index + timeline_layout_1.TIMELINE_PADDING,
+                    height: index % video.fps === 0
+                        ? 10
+                        : (index / frameMarkerEveryNth) % 2 === 0
+                            ? 5
+                            : 2,
+                },
+                showTime: false,
+            };
+        })
+            .filter((_, idx) => idx % frameMarkerEveryNth === 0);
+        // Merge and deduplicate ticks
+        const hasTicks = [];
+        return [...secondTicks, ...frameTicks].filter((t) => {
+            const alreadyUsed = hasTicks.find((ht) => ht === t.frame) !== undefined;
+            hasTicks.push(t.frame);
+            return !alreadyUsed;
+        });
+    }, [video, windowWidth]);
+    if (!video) {
+        return null;
+    }
+    return ((0, jsx_runtime_1.jsx)("div", { ref: ref, style: style, children: ticks.map((t) => {
+            return ((0, jsx_runtime_1.jsx)("div", { style: t.style, children: t.showTime ? ((0, jsx_runtime_1.jsx)("div", { style: tickLabel, children: (0, render_frame_1.renderFrame)(t.frame, video.fps) })) : null }, t.frame));
+        }) }));
+};
+exports.TimelineTimeIndicators = TimelineTimeIndicators;

package/dist/editor/components/Timeline/TimelineTracks.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { TrackWithHash } from '../../helpers/get-timeline-sequence-sort-key';
-import { TimelineViewState } from './timeline-state-reducer';
+import type { TrackWithHash } from '../../helpers/get-timeline-sequence-sort-key';
+import type { TimelineViewState } from './timeline-state-reducer';
 export declare const TimelineTracks: React.FC<{
     timeline: TrackWithHash[];
     fps: number;

package/dist/editor/components/Timeline/TimelineTracks.js

@@ -7,14 +7,13 @@ const timeline_layout_1 = require("../../helpers/timeline-layout");
 const is_collapsed_1 = require("./is-collapsed");
 const MaxTimelineTracks_1 = require("./MaxTimelineTracks");
 const TimelineSequence_1 = require("./TimelineSequence");
+const TimelineTimeIndicators_1 = require("./TimelineTimeIndicators");
 const content = {
     paddingLeft: timeline_layout_1.TIMELINE_PADDING,
     paddingRight: timeline_layout_1.TIMELINE_PADDING,
 };
 const timelineContent = {
-    flex: 1,
-    backgroundColor: '#111111',
-    width: '100%',
+    minHeight: '100%',
 };
 const TimelineTracks = ({ timeline, fps, viewState, hasBeenCut }) => {
     const inner = (0, react_1.useMemo)(() => {
@@ -22,11 +21,17 @@ const TimelineTracks = ({ timeline, fps, viewState, hasBeenCut }) => {
             height: timeline_layout_1.TIMELINE_LAYER_HEIGHT + timeline_layout_1.TIMELINE_BORDER * 2,
         };
     }, []);
-    return ((0, jsx_runtime_1.jsxs)("div", { style: timelineContent, children: [(0, jsx_runtime_1.jsx)("div", { style: content, children: timeline.map((track) => {
-                    if ((0, is_collapsed_1.isTrackHidden)(track, timeline, viewState)) {
-                        return null;
-                    }
-                    return ((0, jsx_runtime_1.jsx)("div", { style: inner, children: (0, jsx_runtime_1.jsx)(TimelineSequence_1.TimelineSequence, { fps: fps, s: track.sequence }) }, track.sequence.id));
-                }) }), hasBeenCut ? (0, jsx_runtime_1.jsx)(MaxTimelineTracks_1.MaxTimelineTracksReached, {}) : null] }));
+    const timelineStyle = (0, react_1.useMemo)(() => {
+        return {
+            ...timelineContent,
+            width: 100 + '%',
+        };
+    }, []);
+    return ((0, jsx_runtime_1.jsxs)("div", { style: timelineStyle, children: [(0, jsx_runtime_1.jsxs)("div", { style: content, children: [(0, jsx_runtime_1.jsx)(TimelineTimeIndicators_1.TimelineTimePadding, {}), timeline.map((track) => {
+                        if ((0, is_collapsed_1.isTrackHidden)(track, timeline, viewState)) {
+                            return null;
+                        }
+                        return ((0, jsx_runtime_1.jsx)("div", { style: inner, children: (0, jsx_runtime_1.jsx)(TimelineSequence_1.TimelineSequence, { fps: fps, s: track.sequence }) }, track.sequence.id));
+                    }), (0, jsx_runtime_1.jsx)(TimelineTimeIndicators_1.TimelineTimeIndicators, {})] }), hasBeenCut ? (0, jsx_runtime_1.jsx)(MaxTimelineTracks_1.MaxTimelineTracksReached, {}) : null] }));
 };
 exports.TimelineTracks = TimelineTracks;

package/dist/editor/components/Timeline/TimelineZoomControls.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const TimelineZoomControls: React.FC;

package/dist/editor/components/Timeline/TimelineZoomControls.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimelineZoomControls = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const is_current_selected_still_1 = require("../../helpers/is-current-selected-still");
+const minus_1 = require("../../icons/minus");
+const plus_1 = require("../../icons/plus");
+const timeline_zoom_1 = require("../../state/timeline-zoom");
+const z_index_1 = require("../../state/z-index");
+const ControlButton_1 = require("../ControlButton");
+const layout_1 = require("../layout");
+const container = {
+    color: 'black',
+    flexDirection: 'row',
+    display: 'flex',
+};
+const buttonStyle = {
+    fontSize: 24,
+};
+const iconStyle = {
+    color: 'white',
+    width: 14,
+};
+const slider = {
+    width: 60,
+    accentColor: 'var(--blue)',
+};
+const TimelineZoomControls = () => {
+    const { setZoom, zoom } = (0, react_1.useContext)(timeline_zoom_1.TimelineZoomCtx);
+    const { tabIndex } = (0, z_index_1.useZIndex)();
+    const onMinusClicked = (0, react_1.useCallback)(() => {
+        setZoom((z) => Math.max(timeline_zoom_1.TIMELINE_MIN_ZOOM, z - 0.2));
+    }, [setZoom]);
+    const onPlusClicked = (0, react_1.useCallback)(() => {
+        setZoom((z) => Math.min(timeline_zoom_1.TIMELINE_MAX_ZOOM, z + 0.2));
+    }, [setZoom]);
+    const onChange = (0, react_1.useCallback)((e) => {
+        setZoom(() => Number(e.target.value));
+    }, [setZoom]);
+    const isStill = (0, is_current_selected_still_1.useIsStill)();
+    if (isStill) {
+        return null;
+    }
+    return ((0, jsx_runtime_1.jsxs)("div", { style: container, children: [(0, jsx_runtime_1.jsx)(ControlButton_1.ControlButton, { onClick: onMinusClicked, style: buttonStyle, title: "Zoom out timeline", role: 'ControlButton', type: "button", disabled: timeline_zoom_1.TIMELINE_MIN_ZOOM === zoom, children: (0, jsx_runtime_1.jsx)(minus_1.Minus, { style: iconStyle }) }), (0, jsx_runtime_1.jsx)(layout_1.Spacing, { x: 0.5 }), (0, jsx_runtime_1.jsx)("input", { title: `Timeline zoom (${zoom}x)`, alt: `Timeline zoom (${zoom}x)`, type: 'range', min: timeline_zoom_1.TIMELINE_MIN_ZOOM, step: 0.1, value: zoom, max: timeline_zoom_1.TIMELINE_MAX_ZOOM, onChange: onChange, style: slider, tabIndex: tabIndex }), (0, jsx_runtime_1.jsx)(layout_1.Spacing, { x: 0.5 }), (0, jsx_runtime_1.jsx)(ControlButton_1.ControlButton, { onClick: onPlusClicked, style: buttonStyle, title: "Zoom in timeline", role: 'button', type: "button", disabled: timeline_zoom_1.TIMELINE_MAX_ZOOM === zoom, children: (0, jsx_runtime_1.jsx)(plus_1.Plus, { style: iconStyle }) })] }));
+};
+exports.TimelineZoomControls = TimelineZoomControls;

package/dist/editor/components/Timeline/imperative-state.d.ts

@@ -0,0 +1,12 @@
+export declare let currentFrame: number;
+export declare let currentZoom: number;
+export declare let currentDuration: number;
+export declare let currentFps: number;
+export declare const getCurrentZoom: () => number;
+export declare const setCurrentZoom: (z: number) => void;
+export declare const getCurrentFrame: () => number;
+export declare const setCurrentFrame: (f: number) => void;
+export declare const getCurrentDuration: () => number;
+export declare const setCurrentDuration: (d: number) => void;
+export declare const getCurrentFps: () => number;
+export declare const setCurrentFps: (d: number) => void;

package/dist/editor/components/Timeline/imperative-state.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCurrentFps = exports.getCurrentFps = exports.setCurrentDuration = exports.getCurrentDuration = exports.setCurrentFrame = exports.getCurrentFrame = exports.setCurrentZoom = exports.getCurrentZoom = exports.currentFps = exports.currentDuration = exports.currentZoom = exports.currentFrame = void 0;
+exports.currentFrame = 0;
+exports.currentZoom = 1;
+exports.currentDuration = 1;
+exports.currentFps = 1;
+const getCurrentZoom = () => {
+    return exports.currentZoom;
+};
+exports.getCurrentZoom = getCurrentZoom;
+const setCurrentZoom = (z) => {
+    exports.currentZoom = z;
+};
+exports.setCurrentZoom = setCurrentZoom;
+const getCurrentFrame = () => {
+    return exports.currentFrame;
+};
+exports.getCurrentFrame = getCurrentFrame;
+const setCurrentFrame = (f) => {
+    exports.currentFrame = f;
+};
+exports.setCurrentFrame = setCurrentFrame;
+const getCurrentDuration = () => {
+    return exports.currentDuration;
+};
+exports.getCurrentDuration = getCurrentDuration;
+const setCurrentDuration = (d) => {
+    exports.currentDuration = d;
+};
+exports.setCurrentDuration = setCurrentDuration;
+const getCurrentFps = () => {
+    return exports.currentFps;
+};
+exports.getCurrentFps = getCurrentFps;
+const setCurrentFps = (d) => {
+    exports.currentFps = d;
+};
+exports.setCurrentFps = setCurrentFps;

package/dist/editor/components/Timeline/is-collapsed.d.ts

@@ -1,4 +1,4 @@
-import { TrackWithHash } from '../../helpers/get-timeline-sequence-sort-key';
-import { TimelineViewState } from './timeline-state-reducer';
+import type { TrackWithHash } from '../../helpers/get-timeline-sequence-sort-key';
+import type { TimelineViewState } from './timeline-state-reducer';
 export declare const isTrackCollapsed: (hash: string, viewState: TimelineViewState) => boolean;
 export declare const isTrackHidden: (track: TrackWithHash, allTracks: TrackWithHash[], viewState: TimelineViewState) => boolean;

package/dist/editor/components/Timeline/timeline-refs.d.ts

@@ -1,2 +1,4 @@
 import React from 'react';
 export declare const sliderAreaRef: React.RefObject<HTMLDivElement>;
+export declare const scrollableRef: React.RefObject<HTMLDivElement>;
+export declare const timelineVerticalScroll: React.RefObject<HTMLDivElement>;

package/dist/editor/components/Timeline/timeline-refs.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sliderAreaRef = void 0;
+exports.timelineVerticalScroll = exports.scrollableRef = exports.sliderAreaRef = void 0;
 const react_1 = __importDefault(require("react"));
 exports.sliderAreaRef = react_1.default.createRef();
+exports.scrollableRef = react_1.default.createRef();
+exports.timelineVerticalScroll = react_1.default.createRef();

package/dist/editor/components/Timeline/timeline-scroll-logic.d.ts

@@ -0,0 +1,44 @@
+export declare const canScrollTimelineIntoDirection: () => {
+    canScrollRight: boolean;
+    canScrollLeft: boolean;
+};
+export declare const getFrameWhileScrollingLeft: ({ durationInFrames, width, }: {
+    durationInFrames: number;
+    width: number;
+}) => number;
+export declare const isCursorInViewport: ({ frame, durationInFrames, }: {
+    frame: number;
+    durationInFrames: number;
+}) => boolean;
+export declare const ensureFrameIsInViewport: ({ direction, durationInFrames, frame, }: {
+    direction: 'fit-left' | 'fit-right' | 'page-right' | 'page-left' | 'center';
+    durationInFrames: number;
+    frame: number;
+}) => void;
+export declare const scrollToTimelineXOffset: (scrollPos: number) => void;
+export declare const getScrollPositionForCursorOnLeftEdge: ({ nextFrame, durationInFrames, }: {
+    nextFrame: number;
+    durationInFrames: number;
+}) => number;
+export declare const getScrollPositionForCursorOnRightEdge: ({ nextFrame, durationInFrames, }: {
+    nextFrame: number;
+    durationInFrames: number;
+}) => number;
+export declare const getFrameIncrement: (durationInFrames: number) => number;
+export declare const getFrameIncrementFromWidth: (durationInFrames: number, width: number) => number;
+export declare const getFrameWhileScrollingRight: ({ durationInFrames, width, }: {
+    durationInFrames: number;
+    width: number;
+}) => number;
+export declare const getFrameFromX: ({ clientX, durationInFrames, width, extrapolate, }: {
+    clientX: number;
+    durationInFrames: number;
+    width: number;
+    extrapolate: 'clamp' | 'extend';
+}) => number;
+export declare const zoomAndPreserveCursor: ({ oldZoom, newZoom, currentFrame, currentDurationInFrames, }: {
+    oldZoom: number;
+    newZoom: number;
+    currentFrame: number;
+    currentDurationInFrames: number;
+}) => void;

package/dist/editor/components/Timeline/timeline-scroll-logic.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zoomAndPreserveCursor = exports.getFrameFromX = exports.getFrameWhileScrollingRight = exports.getFrameIncrementFromWidth = exports.getFrameIncrement = exports.getScrollPositionForCursorOnRightEdge = exports.getScrollPositionForCursorOnLeftEdge = exports.scrollToTimelineXOffset = exports.ensureFrameIsInViewport = exports.isCursorInViewport = exports.getFrameWhileScrollingLeft = exports.canScrollTimelineIntoDirection = void 0;
+const remotion_1 = require("remotion");
+const timeline_layout_1 = require("../../helpers/timeline-layout");
+const timeline_refs_1 = require("./timeline-refs");
+const TimelineSlider_1 = require("./TimelineSlider");
+const canScrollTimelineIntoDirection = () => {
+    const current = timeline_refs_1.scrollableRef.current;
+    const { scrollWidth, scrollLeft, clientWidth } = current;
+    const canScrollRight = scrollWidth - scrollLeft - clientWidth > timeline_layout_1.TIMELINE_PADDING;
+    const canScrollLeft = scrollLeft > timeline_layout_1.TIMELINE_PADDING;
+    return { canScrollRight, canScrollLeft };
+};
+exports.canScrollTimelineIntoDirection = canScrollTimelineIntoDirection;
+const SCROLL_INCREMENT = 200;
+const calculateFrameWhileScrollingRight = ({ durationInFrames, width, scrollLeft, }) => {
+    var _a;
+    return ((0, exports.getFrameFromX)({
+        clientX: scrollLeft,
+        durationInFrames,
+        width,
+        extrapolate: 'clamp',
+    }) +
+        Math.ceil((((_a = timeline_refs_1.scrollableRef.current) === null || _a === void 0 ? void 0 : _a.clientWidth) - timeline_layout_1.TIMELINE_PADDING) /
+            (0, exports.getFrameIncrement)(durationInFrames)));
+};
+const getFrameWhileScrollingLeft = ({ durationInFrames, width, }) => {
+    var _a, _b;
+    const nextFrame = (0, exports.getFrameFromX)({
+        clientX: ((_a = timeline_refs_1.scrollableRef.current) === null || _a === void 0 ? void 0 : _a.scrollLeft) - SCROLL_INCREMENT,
+        durationInFrames,
+        width,
+        extrapolate: 'clamp',
+    });
+    const currentFrame = (0, exports.getFrameFromX)({
+        clientX: (_b = timeline_refs_1.scrollableRef.current) === null || _b === void 0 ? void 0 : _b.scrollLeft,
+        durationInFrames,
+        width,
+        extrapolate: 'clamp',
+    });
+    // Should go back at least 1 frame, but not less than 0
+    return Math.max(0, Math.min(currentFrame - 1, nextFrame));
+};
+exports.getFrameWhileScrollingLeft = getFrameWhileScrollingLeft;
+const isCursorInViewport = ({ frame, durationInFrames, }) => {
+    var _a, _b, _c, _d;
+    const width = (_b = (_a = timeline_refs_1.scrollableRef.current) === null || _a === void 0 ? void 0 : _a.scrollWidth) !== null && _b !== void 0 ? _b : 0;
+    const scrollLeft = (_d = (_c = timeline_refs_1.scrollableRef.current) === null || _c === void 0 ? void 0 : _c.scrollLeft) !== null && _d !== void 0 ? _d : 0;
+    const scrollPosOnRightEdge = (0, exports.getScrollPositionForCursorOnRightEdge)({
+        nextFrame: frame,
+        durationInFrames,
+    });
+    const scrollPosOnLeftEdge = (0, exports.getScrollPositionForCursorOnLeftEdge)({
+        nextFrame: frame,
+        durationInFrames,
+    });
+    const currentFrameRight = calculateFrameWhileScrollingRight({
+        durationInFrames,
+        scrollLeft,
+        width,
+    });
+    return !(scrollPosOnRightEdge >=
+        (0, exports.getScrollPositionForCursorOnRightEdge)({
+            nextFrame: currentFrameRight,
+            durationInFrames,
+        }) || scrollPosOnLeftEdge < scrollLeft);
+};
+exports.isCursorInViewport = isCursorInViewport;
+const ensureFrameIsInViewport = ({ direction, durationInFrames, frame, }) => {
+    var _a, _b, _c, _d, _e;
+    (_a = TimelineSlider_1.redrawTimelineSliderFast.current) === null || _a === void 0 ? void 0 : _a.draw(frame);
+    const width = (_c = (_b = timeline_refs_1.scrollableRef.current) === null || _b === void 0 ? void 0 : _b.scrollWidth) !== null && _c !== void 0 ? _c : 0;
+    const scrollLeft = (_e = (_d = timeline_refs_1.scrollableRef.current) === null || _d === void 0 ? void 0 : _d.scrollLeft) !== null && _e !== void 0 ? _e : 0;
+    if (direction === 'fit-left') {
+        const currentFrameLeft = (0, exports.getFrameFromX)({
+            clientX: scrollLeft,
+            durationInFrames,
+            width,
+            extrapolate: 'clamp',
+        });
+        const scrollPos = (0, exports.getScrollPositionForCursorOnLeftEdge)({
+            nextFrame: frame,
+            durationInFrames,
+        });
+        const needsToScrollLeft = scrollPos <=
+            (0, exports.getScrollPositionForCursorOnLeftEdge)({
+                nextFrame: currentFrameLeft,
+                durationInFrames,
+            });
+        if (needsToScrollLeft) {
+            (0, exports.scrollToTimelineXOffset)(scrollPos);
+        }
+    }
+    if (direction === 'fit-right') {
+        const currentFrameRight = calculateFrameWhileScrollingRight({
+            durationInFrames,
+            scrollLeft,
+            width,
+        });
+        const scrollPos = (0, exports.getScrollPositionForCursorOnRightEdge)({
+            nextFrame: frame,
+            durationInFrames,
+        });
+        const needsToScrollRight = scrollPos >=
+            (0, exports.getScrollPositionForCursorOnRightEdge)({
+                nextFrame: currentFrameRight,
+                durationInFrames,
+            });
+        if (needsToScrollRight) {
+            (0, exports.scrollToTimelineXOffset)(scrollPos);
+        }
+    }
+    if (direction === 'page-right' || direction === 'page-left') {
+        if (!(0, exports.isCursorInViewport)({ frame, durationInFrames })) {
+            (0, exports.scrollToTimelineXOffset)(direction === 'page-left'
+                ? (0, exports.getScrollPositionForCursorOnRightEdge)({
+                    nextFrame: frame,
+                    durationInFrames,
+                })
+                : (0, exports.getScrollPositionForCursorOnLeftEdge)({
+                    nextFrame: frame,
+                    durationInFrames,
+                }));
+        }
+    }
+    if (direction === 'center') {
+        const scrollPosOnRightEdge = (0, exports.getScrollPositionForCursorOnRightEdge)({
+            nextFrame: frame,
+            durationInFrames,
+        });
+        const scrollPosOnLeftEdge = (0, exports.getScrollPositionForCursorOnLeftEdge)({
+            nextFrame: frame,
+            durationInFrames,
+        });
+        (0, exports.scrollToTimelineXOffset)((scrollPosOnLeftEdge + scrollPosOnRightEdge) / 2);
+    }
+};
+exports.ensureFrameIsInViewport = ensureFrameIsInViewport;
+const scrollToTimelineXOffset = (scrollPos) => {
+    var _a;
+    (_a = timeline_refs_1.scrollableRef.current) === null || _a === void 0 ? void 0 : _a.scroll({
+        left: scrollPos,
+    });
+};
+exports.scrollToTimelineXOffset = scrollToTimelineXOffset;
+const getScrollPositionForCursorOnLeftEdge = ({ nextFrame, durationInFrames, }) => {
+    const frameIncrement = (0, exports.getFrameIncrement)(durationInFrames);
+    const scrollPos = frameIncrement * nextFrame;
+    return scrollPos;
+};
+exports.getScrollPositionForCursorOnLeftEdge = getScrollPositionForCursorOnLeftEdge;
+const getScrollPositionForCursorOnRightEdge = ({ nextFrame, durationInFrames, }) => {
+    var _a, _b;
+    const frameIncrement = (0, exports.getFrameIncrement)(durationInFrames);
+    const framesRemaining = durationInFrames - 1 - nextFrame;
+    const fromRight = framesRemaining * frameIncrement + timeline_layout_1.TIMELINE_PADDING;
+    const scrollPos = ((_a = timeline_refs_1.scrollableRef.current) === null || _a === void 0 ? void 0 : _a.scrollWidth) -
+        fromRight -
+        ((_b = timeline_refs_1.scrollableRef.current) === null || _b === void 0 ? void 0 : _b.clientWidth) +
+        timeline_layout_1.TIMELINE_PADDING +
+        4; // clearfix;
+    return scrollPos;
+};
+exports.getScrollPositionForCursorOnRightEdge = getScrollPositionForCursorOnRightEdge;
+const getFrameIncrement = (durationInFrames) => {
+    var _a, _b;
+    const width = (_b = (_a = timeline_refs_1.scrollableRef.current) === null || _a === void 0 ? void 0 : _a.scrollWidth) !== null && _b !== void 0 ? _b : 0;
+    return (0, exports.getFrameIncrementFromWidth)(durationInFrames, width);
+};
+exports.getFrameIncrement = getFrameIncrement;
+const getFrameIncrementFromWidth = (durationInFrames, width) => {
+    return (width - timeline_layout_1.TIMELINE_PADDING * 2) / (durationInFrames - 1);
+};
+exports.getFrameIncrementFromWidth = getFrameIncrementFromWidth;
+const getFrameWhileScrollingRight = ({ durationInFrames, width, }) => {
+    var _a, _b;
+    const nextFrame = calculateFrameWhileScrollingRight({
+        durationInFrames,
+        width,
+        scrollLeft: ((_a = timeline_refs_1.scrollableRef.current) === null || _a === void 0 ? void 0 : _a.scrollLeft) + SCROLL_INCREMENT,
+    });
+    const currentFrame = calculateFrameWhileScrollingRight({
+        durationInFrames,
+        width,
+        scrollLeft: (_b = timeline_refs_1.scrollableRef.current) === null || _b === void 0 ? void 0 : _b.scrollLeft,
+    });
+    // Should scroll by at least 1 frame, but not overshoot duration
+    return Math.min(durationInFrames - 1, Math.max(nextFrame, currentFrame + 1));
+};
+exports.getFrameWhileScrollingRight = getFrameWhileScrollingRight;
+const getFrameFromX = ({ clientX, durationInFrames, width, extrapolate, }) => {
+    var _a;
+    const pos = clientX - timeline_layout_1.TIMELINE_PADDING;
+    const frame = Math.round((0, remotion_1.interpolate)(pos, [0, width - timeline_layout_1.TIMELINE_PADDING * 2], [0, (_a = durationInFrames - 1) !== null && _a !== void 0 ? _a : 0], {
+        extrapolateLeft: extrapolate,
+        extrapolateRight: extrapolate,
+    }));
+    return frame;
+};
+exports.getFrameFromX = getFrameFromX;
+const zoomAndPreserveCursor = ({ oldZoom, newZoom, currentFrame, currentDurationInFrames, }) => {
+    var _a, _b, _c;
+    const ratio = newZoom / oldZoom;
+    if (ratio === 1) {
+        return;
+    }
+    const { current } = timeline_refs_1.scrollableRef;
+    if (!current) {
+        return;
+    }
+    const frameIncrement = (0, exports.getFrameIncrement)(currentDurationInFrames);
+    const prevCursorPosition = frameIncrement * currentFrame + timeline_layout_1.TIMELINE_PADDING;
+    const newCursorPosition = ratio * (prevCursorPosition - timeline_layout_1.TIMELINE_PADDING) + timeline_layout_1.TIMELINE_PADDING;
+    current.scrollLeft += newCursorPosition - prevCursorPosition;
+    (_a = TimelineSlider_1.redrawTimelineSliderFast.current) === null || _a === void 0 ? void 0 : _a.draw(currentFrame, ((_c = (_b = timeline_refs_1.scrollableRef.current) === null || _b === void 0 ? void 0 : _b.clientWidth) !== null && _c !== void 0 ? _c : 0) * ratio);
+};
+exports.zoomAndPreserveCursor = zoomAndPreserveCursor;

package/dist/editor/components/TimelineInOutToggle.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 export declare const inOutHandles: React.RefObject<{
-    inMarkClick: () => void;
-    outMarkClick: () => void;
+    inMarkClick: (e: KeyboardEvent | null) => void;
+    outMarkClick: (e: KeyboardEvent | null) => void;
     clearMarks: () => void;
     setMarks: (marks: [number | null, number | null]) => void;
 }>;