@remotion/cli 4.0.111 → 4.0.113

package/dist/editor/state/checkerboard.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+type State = {
+    checkerboard: boolean;
+    setCheckerboard: (cb: (prevState: boolean) => boolean) => void;
+};
+export declare const persistCheckerboardOption: (option: boolean) => void;
+export declare const loadCheckerboardOption: () => boolean;
+export declare const CheckerboardContext: import("react").Context<State>;
+export {};

package/dist/editor/state/checkerboard.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckerboardContext = exports.loadCheckerboardOption = exports.persistCheckerboardOption = void 0;
+const react_1 = require("react");
+const persistCheckerboardOption = (option) => {
+    localStorage.setItem('option', String(option));
+};
+exports.persistCheckerboardOption = persistCheckerboardOption;
+const loadCheckerboardOption = () => {
+    const item = localStorage.getItem('option');
+    return item !== 'false';
+};
+exports.loadCheckerboardOption = loadCheckerboardOption;
+exports.CheckerboardContext = (0, react_1.createContext)({
+    checkerboard: (0, exports.loadCheckerboardOption)(),
+    setCheckerboard: () => undefined,
+});

package/dist/editor/state/editor-guides.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="react" />
+export type Guide = {
+    orientation: 'horizontal' | 'vertical';
+    position: number;
+    show: boolean;
+    id: string;
+    compositionId: string;
+};
+export type GuideState = {
+    editorShowGuides: boolean;
+    setEditorShowGuides: (cb: (prevState: boolean) => boolean) => void;
+    guidesList: Guide[];
+    setGuidesList: (cb: (prevState: Guide[]) => Guide[]) => void;
+    selectedGuideId: string | null;
+    setSelectedGuideId: (cb: (prevState: string | null) => string | null) => void;
+    setHoveredGuideId: (cb: (prevState: string | null) => string | null) => void;
+    hoveredGuideId: string | null;
+    shouldCreateGuideRef: React.MutableRefObject<boolean>;
+    shouldDeleteGuideRef: React.MutableRefObject<boolean>;
+};
+export declare const persistEditorShowGuidesOption: (option: boolean) => void;
+export declare const loadEditorShowGuidesOption: () => boolean;
+export declare const persistGuidesList: (guides: Guide[]) => void;
+export declare const loadGuidesList: () => Guide[];
+export declare const EditorShowGuidesContext: import("react").Context<GuideState>;

package/dist/editor/state/editor-guides.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditorShowGuidesContext = exports.loadGuidesList = exports.persistGuidesList = exports.loadEditorShowGuidesOption = exports.persistEditorShowGuidesOption = void 0;
+const react_1 = require("react");
+const persistEditorShowGuidesOption = (option) => {
+    localStorage.setItem('remotion.editorShowGuides', String(option));
+};
+exports.persistEditorShowGuidesOption = persistEditorShowGuidesOption;
+const loadEditorShowGuidesOption = () => {
+    const item = localStorage.getItem('remotion.editorShowGuides');
+    return item === 'true';
+};
+exports.loadEditorShowGuidesOption = loadEditorShowGuidesOption;
+const persistGuidesList = (guides) => {
+    localStorage.setItem('remotion.guidesList', JSON.stringify(guides));
+};
+exports.persistGuidesList = persistGuidesList;
+const loadGuidesList = () => {
+    const item = localStorage.getItem('remotion.guidesList');
+    return item ? JSON.parse(item) : [];
+};
+exports.loadGuidesList = loadGuidesList;
+exports.EditorShowGuidesContext = (0, react_1.createContext)({
+    editorShowGuides: false,
+    setEditorShowGuides: () => undefined,
+    guidesList: [],
+    setGuidesList: () => undefined,
+    selectedGuideId: null,
+    setSelectedGuideId: () => undefined,
+    shouldCreateGuideRef: { current: false },
+    shouldDeleteGuideRef: { current: false },
+    hoveredGuideId: null,
+    setHoveredGuideId: () => undefined,
+});

package/dist/editor/state/editor-rulers.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+type State = {
+    editorShowRulers: boolean;
+    setEditorShowRulers: (cb: (prevState: boolean) => boolean) => void;
+};
+export declare const persistEditorShowRulersOption: (option: boolean) => void;
+export declare const loadEditorShowRulersOption: () => boolean;
+export declare const EditorShowRulersContext: import("react").Context<State>;
+export declare const RULER_WIDTH = 20;
+export declare const MINIMUM_VISIBLE_CANVAS_SIZE = 50;
+export declare const PREDEFINED_RULER_SCALE_GAPS: number[];
+export declare const MAXIMUM_PREDEFINED_RULER_SCALE_GAP = 5000;
+export declare const MINIMUM_RULER_MARKING_GAP_PX = 50;
+export {};

package/dist/editor/state/editor-rulers.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MINIMUM_RULER_MARKING_GAP_PX = exports.MAXIMUM_PREDEFINED_RULER_SCALE_GAP = exports.PREDEFINED_RULER_SCALE_GAPS = exports.MINIMUM_VISIBLE_CANVAS_SIZE = exports.RULER_WIDTH = exports.EditorShowRulersContext = exports.loadEditorShowRulersOption = exports.persistEditorShowRulersOption = void 0;
+const react_1 = require("react");
+const persistEditorShowRulersOption = (option) => {
+    localStorage.setItem('remotion.editorShowRulers', String(option));
+};
+exports.persistEditorShowRulersOption = persistEditorShowRulersOption;
+const loadEditorShowRulersOption = () => {
+    const item = localStorage.getItem('remotion.editorShowRulers');
+    return item === 'true';
+};
+exports.loadEditorShowRulersOption = loadEditorShowRulersOption;
+exports.EditorShowRulersContext = (0, react_1.createContext)({
+    editorShowRulers: (0, exports.loadEditorShowRulersOption)(),
+    setEditorShowRulers: () => undefined,
+});
+exports.RULER_WIDTH = 20;
+exports.MINIMUM_VISIBLE_CANVAS_SIZE = 50;
+exports.PREDEFINED_RULER_SCALE_GAPS = [
+    1, 2, 5, 10, 20, 50, 100, 250, 500, 1000, 2000, 5000,
+];
+exports.MAXIMUM_PREDEFINED_RULER_SCALE_GAP = 5000;
+exports.MINIMUM_RULER_MARKING_GAP_PX = 50;

package/dist/editor/state/editor-zoom-gestures.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+type State = {
+    editorZoomGestures: boolean;
+    setEditorZoomGestures: (cb: (prevState: boolean) => boolean) => void;
+};
+export declare const persistEditorZoomGesturesOption: (option: boolean) => void;
+export declare const loadEditorZoomGesturesOption: () => boolean;
+export declare const EditorZoomGesturesContext: import("react").Context<State>;
+export {};

package/dist/editor/state/editor-zoom-gestures.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditorZoomGesturesContext = exports.loadEditorZoomGesturesOption = exports.persistEditorZoomGesturesOption = void 0;
+const react_1 = require("react");
+const persistEditorZoomGesturesOption = (option) => {
+    localStorage.setItem('remotion.editorZoomGestures', String(option));
+};
+exports.persistEditorZoomGesturesOption = persistEditorZoomGesturesOption;
+const loadEditorZoomGesturesOption = () => {
+    const item = localStorage.getItem('remotion.editorZoomGestures');
+    return item !== 'false';
+};
+exports.loadEditorZoomGesturesOption = loadEditorZoomGesturesOption;
+exports.EditorZoomGesturesContext = (0, react_1.createContext)({
+    editorZoomGestures: (0, exports.loadEditorZoomGesturesOption)(),
+    setEditorZoomGestures: () => undefined,
+});

package/dist/editor/state/folders.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { ExpandedFoldersState } from '../helpers/persist-open-folders';
+type TFolderContext = {
+    compositionFoldersExpanded: ExpandedFoldersState;
+    setCompositionFoldersExpanded: React.Dispatch<React.SetStateAction<ExpandedFoldersState>>;
+    assetFoldersExpanded: ExpandedFoldersState;
+    setAssetFoldersExpanded: React.Dispatch<React.SetStateAction<ExpandedFoldersState>>;
+};
+export declare const FolderContext: React.Context<TFolderContext>;
+export declare const FolderContextProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export {};

package/dist/editor/state/folders.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FolderContextProvider = exports.FolderContext = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const persist_open_folders_1 = require("../helpers/persist-open-folders");
+exports.FolderContext = (0, react_1.createContext)({
+    compositionFoldersExpanded: {},
+    setCompositionFoldersExpanded: () => {
+        throw new Error('default state');
+    },
+    assetFoldersExpanded: {},
+    setAssetFoldersExpanded: () => {
+        throw new Error('default state');
+    },
+});
+const FolderContextProvider = ({ children }) => {
+    const [compositionFoldersExpanded, setCompositionFoldersExpanded] = (0, react_1.useState)(() => (0, persist_open_folders_1.loadExpandedFolders)('compositions'));
+    const [assetFoldersExpanded, setAssetFoldersExpanded] = (0, react_1.useState)(() => (0, persist_open_folders_1.loadExpandedFolders)('assets'));
+    const value = (0, react_1.useMemo)(() => {
+        return {
+            compositionFoldersExpanded,
+            setCompositionFoldersExpanded,
+            assetFoldersExpanded,
+            setAssetFoldersExpanded,
+        };
+    }, [assetFoldersExpanded, compositionFoldersExpanded]);
+    return ((0, jsx_runtime_1.jsx)(exports.FolderContext.Provider, { value: value, children: children }));
+};
+exports.FolderContextProvider = FolderContextProvider;

package/dist/editor/state/highest-z-index.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+type HighestZIndexContainer = {
+    highestIndex: number;
+    registerZIndex: (index: number) => void;
+    unregisterZIndex: (index: number) => void;
+};
+export declare const HighestZIndexContext: React.Context<HighestZIndexContainer>;
+export declare const HighestZIndexProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export {};

package/dist/editor/state/highest-z-index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HighestZIndexProvider = exports.HighestZIndexContext = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+exports.HighestZIndexContext = (0, react_1.createContext)({
+    highestIndex: 0,
+    registerZIndex: () => undefined,
+    unregisterZIndex: () => undefined,
+});
+const HighestZIndexProvider = ({ children }) => {
+    const [zIndexes, setZIndexes] = (0, react_1.useState)([]);
+    const registerZIndex = (0, react_1.useCallback)((newIndex) => {
+        setZIndexes((prev) => [...prev, newIndex]);
+    }, []);
+    const unregisterZIndex = (0, react_1.useCallback)((newIndex) => {
+        setZIndexes((prev) => {
+            const index = prev.indexOf(newIndex);
+            if (index === -1) {
+                throw new Error('did not find z-index ' + newIndex);
+            }
+            return prev.filter((_n, i) => i !== index);
+        });
+    }, []);
+    const highestIndex = Math.max(...zIndexes);
+    const value = (0, react_1.useMemo)(() => {
+        return {
+            highestIndex,
+            registerZIndex,
+            unregisterZIndex,
+        };
+    }, [registerZIndex, unregisterZIndex, highestIndex]);
+    return ((0, jsx_runtime_1.jsx)(exports.HighestZIndexContext.Provider, { value: value, children: children }));
+};
+exports.HighestZIndexProvider = HighestZIndexProvider;

package/dist/editor/state/in-out.d.ts

@@ -0,0 +1,13 @@
+import type React from 'react';
+export type InOutValue = {
+    inFrame: number | null;
+    outFrame: number | null;
+};
+export type TimelineInOutContextValue = Record<string, InOutValue>;
+export type SetTimelineInOutContextValue = {
+    setInAndOutFrames: (u: React.SetStateAction<TimelineInOutContextValue>) => void;
+};
+export declare const TimelineInOutContext: React.Context<TimelineInOutContextValue>;
+export declare const SetTimelineInOutContext: React.Context<SetTimelineInOutContextValue>;
+export declare const useTimelineInOutFramePosition: () => InOutValue;
+export declare const useTimelineSetInOutFramePosition: () => SetTimelineInOutContextValue;

package/dist/editor/state/in-out.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTimelineSetInOutFramePosition = exports.useTimelineInOutFramePosition = exports.SetTimelineInOutContext = exports.TimelineInOutContext = void 0;
+const react_1 = require("react");
+const remotion_1 = require("remotion");
+exports.TimelineInOutContext = (0, react_1.createContext)({});
+exports.SetTimelineInOutContext = (0, react_1.createContext)({
+    setInAndOutFrames: () => {
+        throw new Error('default');
+    },
+});
+const useTimelineInOutFramePosition = () => {
+    var _a, _b, _c, _d;
+    const videoConfig = remotion_1.Internals.useUnsafeVideoConfig();
+    const state = (0, react_1.useContext)(exports.TimelineInOutContext);
+    if (!videoConfig) {
+        return { inFrame: null, outFrame: null };
+    }
+    const maxFrame = videoConfig.durationInFrames - 1;
+    const actualInFrame = (_b = (_a = state[videoConfig.id]) === null || _a === void 0 ? void 0 : _a.inFrame) !== null && _b !== void 0 ? _b : null;
+    const actualOutFrame = (_d = (_c = state[videoConfig.id]) === null || _c === void 0 ? void 0 : _c.outFrame) !== null && _d !== void 0 ? _d : null;
+    return {
+        inFrame: actualInFrame === null
+            ? null
+            : actualInFrame >= maxFrame
+                ? null
+                : actualInFrame,
+        outFrame: actualOutFrame === null
+            ? null
+            : actualOutFrame >= maxFrame
+                ? null
+                : actualOutFrame,
+    };
+};
+exports.useTimelineInOutFramePosition = useTimelineInOutFramePosition;
+const useTimelineSetInOutFramePosition = () => {
+    const { setInAndOutFrames } = (0, react_1.useContext)(exports.SetTimelineInOutContext);
+    return { setInAndOutFrames };
+};
+exports.useTimelineSetInOutFramePosition = useTimelineSetInOutFramePosition;

package/dist/editor/state/input-dragger-click-lock.d.ts

@@ -0,0 +1,2 @@
+export declare const getClickLock: () => boolean;
+export declare const setClickLock: (lock: boolean) => void;

package/dist/editor/state/input-dragger-click-lock.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setClickLock = exports.getClickLock = void 0;
+let clickLock = false;
+const getClickLock = () => clickLock;
+exports.getClickLock = getClickLock;
+const setClickLock = (lock) => {
+    clickLock = lock;
+};
+exports.setClickLock = setClickLock;

package/dist/editor/state/keybindings.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+export type KeyEventType = 'keydown' | 'keyup' | 'keypress';
+type KeyListenerCallback = (e: KeyboardEvent) => void;
+export type RegisteredKeybinding = {
+    registeredFromPane: string;
+    id: string;
+    key: string;
+    event: KeyEventType;
+    callback: KeyListenerCallback;
+};
+export type KeybindingContextType = {
+    registerKeybinding: (binding: RegisteredKeybinding) => void;
+    unregisterKeybinding: (binding: RegisteredKeybinding) => void;
+    unregisterPane: (paneId: string) => void;
+};
+export declare const KeybindingContext: React.Context<KeybindingContextType>;
+export declare const KeybindingContextProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export {};

package/dist/editor/state/keybindings.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeybindingContextProvider = exports.KeybindingContext = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+exports.KeybindingContext = (0, react_1.createContext)({
+    registerKeybinding: () => {
+        throw new Error('Has no keybinding context');
+    },
+    unregisterKeybinding: () => undefined,
+    unregisterPane: () => undefined,
+});
+const KeybindingContextProvider = ({ children }) => {
+    const registered = (0, react_1.useRef)([]);
+    const registerKeybinding = (0, react_1.useCallback)((binding) => {
+        registered.current = [...registered.current, binding];
+        window.addEventListener(binding.event, binding.callback);
+    }, []);
+    const unregisterKeybinding = (0, react_1.useCallback)((binding) => {
+        registered.current = registered.current.filter((r) => {
+            if (r.id === binding.id) {
+                window.removeEventListener(binding.event, binding.callback);
+                return false;
+            }
+            return true;
+        });
+    }, []);
+    const unregisterPane = (0, react_1.useCallback)((paneId) => {
+        const matchedKeybindings = registered.current.filter((r) => r.registeredFromPane === paneId);
+        for (const matched of matchedKeybindings) {
+            unregisterKeybinding(matched);
+        }
+    }, [unregisterKeybinding]);
+    const value = (0, react_1.useMemo)(() => {
+        return {
+            registerKeybinding,
+            unregisterKeybinding,
+            unregisterPane,
+        };
+    }, [registerKeybinding, unregisterKeybinding, unregisterPane]);
+    return ((0, jsx_runtime_1.jsx)(exports.KeybindingContext.Provider, { value: value, children: children }));
+};
+exports.KeybindingContextProvider = KeybindingContextProvider;

package/dist/editor/state/loop.d.ts

@@ -0,0 +1,2 @@
+export declare const persistLoopOption: (option: boolean) => void;
+export declare const loadLoopOption: () => boolean;

package/dist/editor/state/loop.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadLoopOption = exports.persistLoopOption = void 0;
+const key = 'remotion.loop';
+const persistLoopOption = (option) => {
+    localStorage.setItem(key, String(option));
+};
+exports.persistLoopOption = persistLoopOption;
+const loadLoopOption = () => {
+    const item = localStorage.getItem(key);
+    return item !== 'false';
+};
+exports.loadLoopOption = loadLoopOption;

package/dist/editor/state/marks.d.ts

@@ -0,0 +1,3 @@
+import type { TimelineInOutContextValue } from './in-out';
+export declare const persistMarks: (marks: TimelineInOutContextValue) => void;
+export declare const loadMarks: () => TimelineInOutContextValue;

package/dist/editor/state/marks.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMarks = exports.persistMarks = void 0;
+const localStorageKey = () => `remotion.editor.marksv2`;
+const persistMarks = (marks) => {
+    localStorage.setItem(localStorageKey(), JSON.stringify(marks));
+};
+exports.persistMarks = persistMarks;
+const loadMarks = () => {
+    const item = localStorage.getItem(localStorageKey());
+    if (item === null) {
+        return {};
+    }
+    return JSON.parse(item);
+};
+exports.loadMarks = loadMarks;

package/dist/editor/state/modals.d.ts

@@ -0,0 +1,61 @@
+import type { AudioCodec, Codec, ColorSpace, LogLevel, OpenGlRenderer, PixelFormat, ProResProfile, StillImageFormat, VideoImageFormat, X264Preset } from '@remotion/renderer';
+import type React from 'react';
+import type { QuickSwitcherMode } from '../components/QuickSwitcher/NoResults';
+import type { Bug, UpdateInfo } from '../components/UpdateCheck';
+export type CompType = 'composition' | 'still';
+export type RenderModalState = {
+    type: 'render';
+    compositionId: string;
+    initialFrame: number;
+    initialStillImageFormat: StillImageFormat;
+    initialVideoImageFormat: VideoImageFormat;
+    initialJpegQuality: number;
+    initialScale: number;
+    initialLogLevel: LogLevel;
+    initialConcurrency: number;
+    initialMuted: boolean;
+    initialEnforceAudioTrack: boolean;
+    initialProResProfile: ProResProfile;
+    initialx264Preset: X264Preset;
+    initialPixelFormat: PixelFormat;
+    initialVideoBitrate: string | null;
+    initialAudioBitrate: string | null;
+    initialEveryNthFrame: number;
+    initialNumberOfGifLoops: number | null;
+    initialDelayRenderTimeout: number;
+    initialEnvVariables: Record<string, string>;
+    initialDisableWebSecurity: boolean;
+    initialOpenGlRenderer: OpenGlRenderer | null;
+    initialIgnoreCertificateErrors: boolean;
+    initialHeadless: boolean;
+    initialOffthreadVideoCacheSizeInBytes: number | null;
+    initialColorSpace: ColorSpace;
+    initialMultiProcessOnLinux: boolean;
+    minConcurrency: number;
+    maxConcurrency: number;
+    defaultProps: Record<string, unknown>;
+    inFrameMark: number | null;
+    outFrameMark: number | null;
+    defaultConfigurationVideoCodec: Codec;
+    defaultConfigurationAudioCodec: AudioCodec | null;
+};
+export type ModalState = {
+    type: 'new-comp';
+    compType: CompType;
+} | RenderModalState | {
+    type: 'render-progress';
+    jobId: string;
+} | {
+    type: 'update';
+    info: UpdateInfo;
+    knownBugs: Bug[];
+} | {
+    type: 'quick-switcher';
+    mode: QuickSwitcherMode;
+    invocationTimestamp: number;
+};
+export type ModalContextType = {
+    selectedModal: ModalState | null;
+    setSelectedModal: React.Dispatch<React.SetStateAction<ModalState | null>>;
+};
+export declare const ModalsContext: React.Context<ModalContextType>;

package/dist/editor/state/modals.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModalsContext = void 0;
+const react_1 = require("react");
+exports.ModalsContext = (0, react_1.createContext)({
+    selectedModal: null,
+    setSelectedModal: () => undefined,
+});

package/dist/editor/state/mute.d.ts

@@ -0,0 +1,2 @@
+export declare const persistMuteOption: (option: boolean) => void;
+export declare const loadMuteOption: () => boolean;

package/dist/editor/state/mute.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMuteOption = exports.persistMuteOption = void 0;
+const key = 'remotion.mute';
+const persistMuteOption = (option) => {
+    localStorage.setItem(key, String(option));
+};
+exports.persistMuteOption = persistMuteOption;
+const loadMuteOption = () => {
+    const item = localStorage.getItem(key);
+    return item === 'true';
+};
+exports.loadMuteOption = loadMuteOption;

package/dist/editor/state/playbackrate.d.ts

@@ -0,0 +1,2 @@
+export declare const persistPlaybackRate: (option: number) => void;
+export declare const loadPlaybackRate: () => number;

package/dist/editor/state/playbackrate.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPlaybackRate = exports.persistPlaybackRate = void 0;
+const key = 'remotion.playbackrate';
+const persistPlaybackRate = (option) => {
+    localStorage.setItem(key, String(option));
+};
+exports.persistPlaybackRate = persistPlaybackRate;
+const loadPlaybackRate = () => {
+    if (typeof window !== 'undefined') {
+        return 1;
+    }
+    const item = localStorage.getItem(key);
+    if (item === null) {
+        return 1;
+    }
+    return Number(item);
+};
+exports.loadPlaybackRate = loadPlaybackRate;

package/dist/editor/state/preview-size.d.ts

@@ -0,0 +1,12 @@
+import type { PreviewSize } from '@remotion/player';
+import React from 'react';
+type PreviewSizeCtx = {
+    size: PreviewSize;
+    setSize: (cb: (oldSize: PreviewSize) => PreviewSize) => void;
+};
+export declare const persistPreviewSizeOption: (option: PreviewSize) => void;
+export declare const PreviewSizeContext: React.Context<PreviewSizeCtx>;
+export declare const PreviewSizeProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export {};

package/dist/editor/state/preview-size.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreviewSizeProvider = exports.PreviewSizeContext = exports.persistPreviewSizeOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const editor_zoom_gestures_1 = require("./editor-zoom-gestures");
+const key = 'remotion.previewSize';
+const persistPreviewSizeOption = (option) => {
+    localStorage.setItem(key, JSON.stringify(option));
+};
+exports.persistPreviewSizeOption = persistPreviewSizeOption;
+const loadPreviewSizeOption = () => {
+    const item = localStorage.getItem(key);
+    if (item === null) {
+        return {
+            size: 'auto',
+            translation: {
+                x: 0,
+                y: 0,
+            },
+        };
+    }
+    return JSON.parse(item);
+};
+exports.PreviewSizeContext = (0, react_1.createContext)({
+    setSize: () => undefined,
+    size: loadPreviewSizeOption(),
+});
+const PreviewSizeProvider = ({ children }) => {
+    const [size, setSizeState] = (0, react_1.useState)(() => loadPreviewSizeOption());
+    const [translation, setTranslation] = (0, react_1.useState)(() => {
+        return {
+            x: 0,
+            y: 0,
+        };
+    });
+    const { editorZoomGestures } = (0, react_1.useContext)(editor_zoom_gestures_1.EditorZoomGesturesContext);
+    const setSize = (0, react_1.useCallback)((newValue) => {
+        setSizeState((prevState) => {
+            const newVal = newValue(prevState);
+            (0, exports.persistPreviewSizeOption)(newVal);
+            return newVal;
+        });
+    }, []);
+    const previewSizeCtx = (0, react_1.useMemo)(() => {
+        return {
+            size: editorZoomGestures
+                ? size
+                : {
+                    size: size.size,
+                    translation: {
+                        x: 0,
+                        y: 0,
+                    },
+                },
+            setSize,
+            translation,
+            setTranslation,
+        };
+    }, [editorZoomGestures, size, setSize, translation]);
+    return ((0, jsx_runtime_1.jsx)(exports.PreviewSizeContext.Provider, { value: previewSizeCtx, children: children }));
+};
+exports.PreviewSizeProvider = PreviewSizeProvider;

package/dist/editor/state/render-frame.d.ts

@@ -0,0 +1 @@
+export declare const renderFrame: (frame: number, fps: number) => string;

package/dist/editor/state/render-frame.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderFrame = void 0;
+const renderFrame = (frame, fps) => {
+    const hours = Math.floor(frame / fps / 3600);
+    const remainingMinutes = frame - hours * fps * 3600;
+    const minutes = Math.floor(remainingMinutes / 60 / fps);
+    const remainingSec = frame - hours * fps * 3600 - minutes * fps * 60;
+    const seconds = Math.floor(remainingSec / fps);
+    const frameAfterSec = Math.round(frame % fps);
+    const hoursStr = String(hours);
+    const minutesStr = String(minutes).padStart(2, '0');
+    const secondsStr = String(seconds).padStart(2, '0');
+    const frameStr = String(frameAfterSec).padStart(2, '0');
+    if (hours > 0) {
+        return `${hoursStr}:${minutesStr}:${secondsStr}.${frameStr}`;
+    }
+    return `${minutesStr}:${secondsStr}.${frameStr}`;
+};
+exports.renderFrame = renderFrame;