@remotion/cli 4.0.111 → 4.0.113

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimelineVideoInfo = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const media_utils_1 = require("@remotion/media-utils");
+const react_1 = require("react");
+const timeline_layout_1 = require("../../helpers/timeline-layout");
+const containerStyle = {
+    height: timeline_layout_1.TIMELINE_LAYER_HEIGHT,
+    width: timeline_layout_1.TIMELINE_LAYER_HEIGHT,
+    backgroundColor: 'rgba(0, 0, 0, 0.3)',
+    display: 'flex',
+    justifyContent: 'center',
+    alignItems: 'center',
+    textAlign: 'center',
+    borderRadius: 2,
+    fontSize: 10,
+    fontFamily: 'Arial, Helvetica',
+};
+const svgStyle = {
+    height: 20,
+};
+const pathStyle = {
+    color: '#8e44ad',
+};
+const TimelineVideoInfo = ({ src }) => {
+    const mountState = (0, react_1.useRef)({ isMounted: true });
+    const [videoMetadata, setVideoMetadata] = (0, react_1.useState)(null);
+    (0, react_1.useEffect)(() => {
+        (0, media_utils_1.getVideoMetadata)(src)
+            .then((data) => {
+            setVideoMetadata(data);
+        })
+            .catch((err) => {
+            // eslint-disable-next-line no-console
+            console.log('Could not get video metadata', err);
+        });
+    }, [src]);
+    (0, react_1.useEffect)(() => {
+        const { current } = mountState;
+        current.isMounted = true;
+        return () => {
+            current.isMounted = false;
+        };
+    }, []);
+    if (!videoMetadata) {
+        return null;
+    }
+    return ((0, jsx_runtime_1.jsx)("div", { style: containerStyle, children: (0, jsx_runtime_1.jsx)("svg", { style: svgStyle, role: "img", viewBox: "0 0 576 512", children: (0, jsx_runtime_1.jsx)("path", { style: pathStyle, fill: "currentColor", d: "M336.2 64H47.8C21.4 64 0 85.4 0 111.8v288.4C0 426.6 21.4 448 47.8 448h288.4c26.4 0 47.8-21.4 47.8-47.8V111.8c0-26.4-21.4-47.8-47.8-47.8zm189.4 37.7L416 177.3v157.4l109.6 75.5c21.2 14.6 50.4-.3 50.4-25.8V127.5c0-25.4-29.1-40.4-50.4-25.8z" }) }) }));
+};
+exports.TimelineVideoInfo = TimelineVideoInfo;

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

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+type TimelineWidthContextType = number | null;
+export declare const TimelineWidthContext: import("react").Context<TimelineWidthContextType>;
+export declare const TimelineWidthProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export {};

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimelineWidthProvider = exports.TimelineWidthContext = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const player_1 = require("@remotion/player");
+const react_1 = require("react");
+const timeline_refs_1 = require("./timeline-refs");
+exports.TimelineWidthContext = (0, react_1.createContext)(null);
+const TimelineWidthProvider = ({ children }) => {
+    var _a;
+    const size = player_1.PlayerInternals.useElementSize(timeline_refs_1.sliderAreaRef, {
+        triggerOnWindowResize: false,
+        shouldApplyCssTransforms: true,
+    });
+    return ((0, jsx_runtime_1.jsx)(exports.TimelineWidthContext.Provider, { value: (_a = size === null || size === void 0 ? void 0 : size.width) !== null && _a !== void 0 ? _a : null, children: children }));
+};
+exports.TimelineWidthProvider = TimelineWidthProvider;

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,46 @@
+"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 remotion_1 = require("remotion");
+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',
+    alignItems: 'center',
+};
+const buttonStyle = {
+    fontSize: 24,
+};
+const iconStyle = {
+    color: 'white',
+    width: 14,
+};
+const TimelineZoomControls = () => {
+    const { canvasContent } = (0, react_1.useContext)(remotion_1.Internals.CompositionManager);
+    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 || canvasContent === null || canvasContent.type === 'asset') {
+        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, className: "__remotion-timeline-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, { color: "currentcolor", style: iconStyle }) })] }));
+};
+exports.TimelineZoomControls = TimelineZoomControls;

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

@@ -0,0 +1,8 @@
+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 = void 0;
+let currentFrame = 0;
+let currentZoom = 1;
+let currentDuration = 1;
+let currentFps = 1;
+const getCurrentZoom = () => {
+    return currentZoom;
+};
+exports.getCurrentZoom = getCurrentZoom;
+const setCurrentZoom = (z) => {
+    currentZoom = z;
+};
+exports.setCurrentZoom = setCurrentZoom;
+const getCurrentFrame = () => {
+    return currentFrame;
+};
+exports.getCurrentFrame = getCurrentFrame;
+const setCurrentFrame = (f) => {
+    currentFrame = f;
+};
+exports.setCurrentFrame = setCurrentFrame;
+const getCurrentDuration = () => {
+    return currentDuration;
+};
+exports.getCurrentDuration = getCurrentDuration;
+const setCurrentDuration = (d) => {
+    currentDuration = d;
+};
+exports.setCurrentDuration = setCurrentDuration;
+const getCurrentFps = () => {
+    return currentFps;
+};
+exports.getCurrentFps = getCurrentFps;
+const setCurrentFps = (d) => {
+    currentFps = d;
+};
+exports.setCurrentFps = setCurrentFps;

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

@@ -0,0 +1,4 @@
+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/is-collapsed.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTrackHidden = exports.isTrackCollapsed = void 0;
+const isTrackCollapsed = (hash, viewState) => {
+    return viewState.collapsed[hash] !== false;
+};
+exports.isTrackCollapsed = isTrackCollapsed;
+const isTrackHidden = (track, allTracks, viewState) => {
+    if (!track.sequence.parent) {
+        return false;
+    }
+    if (!track.canCollapse) {
+        return false;
+    }
+    const parent = allTracks.find((t) => t.sequence.id === track.sequence.parent);
+    // Due to effects and conditional `showInTimeline`, a parent
+    // may not exist in the `allTracks` array.
+    if (!parent) {
+        return true;
+    }
+    if ((0, exports.isTrackCollapsed)(parent.hash, viewState)) {
+        return true;
+    }
+    return (0, exports.isTrackHidden)(parent, allTracks, viewState);
+};
+exports.isTrackHidden = isTrackHidden;

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

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

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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,43 @@
+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 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,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zoomAndPreserveCursor = exports.getFrameFromX = exports.getFrameWhileScrollingRight = exports.getFrameIncrementFromWidth = 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) /
+            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 = getFrameIncrement(durationInFrames);
+    const scrollPos = frameIncrement * nextFrame;
+    return scrollPos;
+};
+exports.getScrollPositionForCursorOnLeftEdge = getScrollPositionForCursorOnLeftEdge;
+const getScrollPositionForCursorOnRightEdge = ({ nextFrame, durationInFrames, }) => {
+    var _a, _b;
+    const frameIncrement = 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);
+};
+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 = 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/Timeline/timeline-state-reducer.d.ts

@@ -0,0 +1,19 @@
+export type TimelineViewState = {
+    collapsed: {
+        [key: string]: boolean;
+    };
+};
+export type TimelineActionState = {
+    type: 'collapse';
+    hash: string;
+} | {
+    type: 'expand';
+    hash: string;
+} | {
+    type: 'expand-all';
+    allHashes: string[];
+} | {
+    type: 'collapse-all';
+    allHashes: string[];
+};
+export declare const timelineStateReducer: (state: TimelineViewState, action: TimelineActionState) => TimelineViewState;

package/dist/editor/components/Timeline/timeline-state-reducer.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timelineStateReducer = void 0;
+const timelineStateReducer = (state, action) => {
+    if (action.type === 'collapse') {
+        return {
+            ...state,
+            collapsed: {
+                ...state.collapsed,
+                [action.hash]: true,
+            },
+        };
+    }
+    if (action.type === 'expand') {
+        return {
+            ...state,
+            collapsed: {
+                ...state.collapsed,
+                [action.hash]: false,
+            },
+        };
+    }
+    if (action.type === 'collapse-all') {
+        return {
+            ...state,
+            collapsed: action.allHashes.reduce((a, b) => {
+                return {
+                    ...[a],
+                    [b]: true,
+                };
+            }, {}),
+        };
+    }
+    if (action.type === 'expand-all') {
+        return {
+            ...state,
+            collapsed: action.allHashes.reduce((a, b) => {
+                return {
+                    ...a,
+                    [b]: false,
+                };
+            }, {}),
+        };
+    }
+    return state;
+};
+exports.timelineStateReducer = timelineStateReducer;

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { InOutValue } from '../state/in-out';
+export declare const inOutHandles: React.RefObject<{
+    inMarkClick: (e: KeyboardEvent | null) => void;
+    outMarkClick: (e: KeyboardEvent | null) => void;
+    clearMarks: () => void;
+}>;
+export declare const defaultInOutValue: InOutValue;
+export declare const TimelineInOutPointToggle: React.FC;