Skip to content

🎥 Make videos programmatically with React

10.0 KB
Raw Blame
"use client";

import type {
  CanvasSequencePropChange,
  CanvasSequencePropStatusResolver,
} from "@remotion/sdk";
import { resolveCompositionComponent } from "@remotion/codemods";
import React, {
  useCallback,
  useEffect,
  useMemo,
  useReducer,
  useRef,
  useSyncExternalStore,
} from "react";
import type { PreviewKeyEvent } from "@/preview/bridge";
import { TooltipProvider } from "@/components/ui/tooltip";
import { EditorLayout } from "./components/EditorLayout";
import { Notices } from "./components/Notices";
import { RenderDialog } from "./components/RenderDialog";
import { ShortcutsDialog } from "./components/ShortcutsDialog";
import { useCompiler } from "./hooks/use-compiler";
import { useEditorActions } from "./hooks/use-editor-actions";
import { useEditorShortcuts } from "./hooks/use-editor-shortcuts";
import { useLayers } from "./hooks/use-layers";
import { usePlaybackStore } from "./hooks/use-playback";
import { usePreviewHost } from "./hooks/use-preview-host";
import { findCompositionFile, getRegistrations } from "./model/compositions";
import { getKeyframedProps } from "./model/keyframes";
import { getSequencePropStatuses } from "./model/layers";
import { toCodemodProject, type ProjectFiles } from "./model/project";
import { EditorContext, type EditorContextValue } from "./state/editor-context";
import {
  createInitialState,
  editorReducer,
  hasUnsavedChanges,
} from "./state/editor-store";

const noopSubscribe = () => () => {};

export const Editor: React.FC<{
  readonly initialFiles: ProjectFiles;
  readonly entryPoint: string;
  readonly canSave: boolean;
}> = ({ initialFiles, entryPoint, canSave }) => {
  const [state, dispatch] = useReducer(editorReducer, initialFiles, (files) => {
    const project = toCodemodProject(files);
    const compositionFile = findCompositionFile(project);
    const first = getRegistrations(project, compositionFile).compositions[0];
    let activeFile = compositionFile;
    if (first && compositionFile) {
      try {
        activeFile = resolveCompositionComponent({
          project,
          compositionFile,
          compositionId: first.id,
        }).filePath;
      } catch {
        // Fall back to the composition file.
      }
    }

    return createInitialState({
      files,
      activeFile: activeFile ?? Object.keys(files)[0] ?? null,
    });
  });

  const iframeRef = useRef<HTMLIFrameElement | null>(null);
  const project = useMemo(() => toCodemodProject(state.files), [state.files]);
  const compiledProject = useMemo(
    () => (state.appliedFiles ? toCodemodProject(state.appliedFiles) : project),
    [project, state.appliedFiles],
  );
  const compositionFile = useMemo(
    () => findCompositionFile(project),
    [project],
  );
  const registrations = useMemo(
    () => getRegistrations(project, compositionFile),
    [compositionFile, project],
  );
  const { compositions } = registrations;
  const activeComposition = useMemo(
    () =>
      compositions.find(
        (composition) => composition.id === state.compositionId,
      ) ?? null,
    [compositions, state.compositionId],
  );

  useEffect(() => {
    if (!activeComposition && compositions.length > 0) {
      dispatch({
        type: "select-composition",
        compositionId: compositions[0].id,
      });
    }
  }, [activeComposition, compositions]);

  const mainFile = useMemo(() => {
    if (!activeComposition || !compositionFile) {
      return null;
    }

    try {
      return resolveCompositionComponent({
        project,
        compositionFile,
        compositionId: activeComposition.id,
      }).filePath;
    } catch {
      return null;
    }
  }, [activeComposition, compositionFile, project]);

  // Switching compositions opens the file that defines it.
  const previousCompositionId = useRef(state.compositionId);
  useEffect(() => {
    if (previousCompositionId.current === state.compositionId) {
      return;
    }

    previousCompositionId.current = state.compositionId;
    if (mainFile) {
      dispatch({ type: "open-file", filePath: mainFile });
    }
  }, [mainFile, state.compositionId]);

  const onPreviewError = useCallback((message: string) => {
    dispatch({ type: "set-runtime-error", message });
  }, []);
  const shortcutHandlerRef = useRef<(event: PreviewKeyEvent) => boolean>(
    () => false,
  );
  const onPreviewKeyDown = useCallback(
    (event: PreviewKeyEvent) => shortcutHandlerRef.current(event),
    [],
  );
  // The actions are created below, after the host they operate on exists.
  const sequencePropsChangeHandlerRef = useRef<
    (changes: readonly CanvasSequencePropChange[]) => void
  >(() => undefined);
  const onPreviewSequencePropsChange = useCallback(
    (changes: readonly CanvasSequencePropChange[]) =>
      sequencePropsChangeHandlerRef.current(changes),
    [],
  );
  const sequencePropStatusResolverRef =
    useRef<CanvasSequencePropStatusResolver>(() => null);
  const getPreviewSequencePropStatuses =
    useCallback<CanvasSequencePropStatusResolver>(
      (nodePathInfo, keys) =>
        sequencePropStatusResolverRef.current(nodePathInfo, keys),
      [],
    );

  const { host, error: hostError } = usePreviewHost({
    iframeRef,
    onError: onPreviewError,
    onKeyDown: onPreviewKeyDown,
    onSequencePropsChange: onPreviewSequencePropsChange,
    getSequencePropStatuses: getPreviewSequencePropStatuses,
  });
  const playback = usePlaybackStore({ host, onError: onPreviewError });
  const composition = useSyncExternalStore(
    host?.subscribe ?? noopSubscribe,
    () => host?.getSnapshot().composition ?? null,
    () => null,
  );
  const layers = useLayers({ host, compiledProject });

  const selection = useMemo(
    () =>
      activeComposition
        ? {
            compositionId: activeComposition.id,
            inputProps: state.propsOverride ?? {},
          }
        : null,
    [activeComposition, state.propsOverride],
  );
  useCompiler({
    host,
    files: state.files,
    entryPoint,
    selection,
    dispatch,
  });

  useEffect(() => {
    if (hostError) {
      dispatch({
        type: "set-compile",
        compile: { type: "error", message: hostError },
      });
    }
  }, [hostError]);

  const {
    loop,
    playbackRate,
    inFrame,
    outFrame,
    zoom,
    showOutlines,
    checkerboard,
  } = state.playback;
  useEffect(() => {
    host?.setOptions({
      loop,
      playbackRate,
      inFrame,
      outFrame,
      zoom,
      showOutlines,
      checkerboard,
    });
  }, [
    checkerboard,
    host,
    inFrame,
    loop,
    outFrame,
    playbackRate,
    showOutlines,
    zoom,
  ]);

  const compositionDurationInFrames =
    composition?.durationInFrames ?? activeComposition?.durationInFrames ?? 1;
  const compositionFps = composition?.fps ?? activeComposition?.fps ?? 30;
  const compositionWidth =
    composition?.width ?? activeComposition?.width ?? 1920;
  const compositionHeight =
    composition?.height ?? activeComposition?.height ?? 1080;

  // The animated props of the layers, for the keyframe rows of the timeline.
  const keyframedProps = useMemo(
    () =>
      getKeyframedProps({
        layers,
        project,
        videoConfig: {
          width: compositionWidth,
          height: compositionHeight,
          fps: compositionFps,
          durationInFrames: compositionDurationInFrames,
        },
      }),
    [
      compositionDurationInFrames,
      compositionFps,
      compositionHeight,
      compositionWidth,
      layers,
      project,
    ],
  );

  const actions = useEditorActions({
    context: {
      state,
      entryPoint,
      host,
      layers,
      keyframedProps,
      compositions,
      compositionFile,
      activeComposition,
      compositionDurationInFrames,
      compositionFps,
      compositionWidth,
      compositionHeight,
    },
    dispatch,
    playback,
    canSave,
  });

  shortcutHandlerRef.current = useEditorShortcuts({
    actions,
    playback,
    context: { state, host, layers, compositions, fps: compositionFps },
  });
  sequencePropsChangeHandlerRef.current = (changes) => {
    void actions.commitSequencePropChanges(changes);
  };
  // The canvas asks before a move starts; analyze the files the edit applies to.
  sequencePropStatusResolverRef.current = (nodePathInfo, keys) =>
    getSequencePropStatuses({
      project,
      nodePathInfo,
      keys,
      videoConfig: {
        width: compositionWidth,
        height: compositionHeight,
        fps: compositionFps,
        durationInFrames: compositionDurationInFrames,
      },
    });

  // Previewed values are released once the preview runs the committed source
  // or the compilation failed, so they never linger over stale output.
  const previewUpToDate = state.appliedFiles === state.files;
  const compileFailed = state.compile.type === "error";
  useEffect(() => {
    if (previewUpToDate || compileFailed) {
      actions.releasePreviews();
    }
  }, [actions, compileFailed, previewUpToDate]);

  useEffect(() => {
    if (state.notices.length === 0) {
      return;
    }

    const [oldest] = state.notices;
    const timeout = window.setTimeout(
      () => dispatch({ type: "dismiss-notice", id: oldest.id }),
      oldest.type === "error" ? 8000 : 3500,
    );
    return () => window.clearTimeout(timeout);
  }, [state.notices]);

  const unsaved = hasUnsavedChanges(state);
  useEffect(() => {
    if (!unsaved) {
      return;
    }

    const onBeforeUnload = (event: BeforeUnloadEvent) => {
      event.preventDefault();
    };

    window.addEventListener("beforeunload", onBeforeUnload);
    return () => window.removeEventListener("beforeunload", onBeforeUnload);
  }, [unsaved]);

  const value: EditorContextValue = {
    state,
    dispatch,
    entryPoint,
    canSave,
    host,
    hostError,
    playback,
    layers,
    keyframedProps,
    project,
    registrations,
    compositions,
    compositionFile,
    mainFile,
    activeComposition,
    composition,
    actions,
  };

  return (
    <EditorContext.Provider value={value}>
      <TooltipProvider>
        <EditorLayout iframeRef={iframeRef} />
        <ShortcutsDialog />
        <RenderDialog />
        <Notices />
      </TooltipProvider>
    </EditorContext.Provider>
  );
};