Skip to content

The open-source full-stack studio for Opus 5.5 motion video. Reverse engineering for any video. Code video with HTML: recreate, edit and render. BYOA + BYOK · Motion.md · Images, Video, Music & Voice.

7.2 KB
Raw Blame
import { useCallback, useRef, useSyncExternalStore, type ReactNode } from "react";
import { PlayerControls } from "../../player";
import { useMvpEditor } from "../../motion/StudioHost";
import type { TimelineElement } from "../../player";
import { useDockHeaderSlot } from "../dock/DockHeaderSlots";
import { PreviewEmptyState } from "./PreviewEmptyState";
import { useEmptyPreview } from "./useEmptyPreview";
import { NLEPreview } from "./NLEPreview";
import { CompositionBreadcrumb } from "./CompositionBreadcrumb";
import { usePreviewBlockDrop } from "./usePreviewBlockDrop";
import { useNLEContext } from "./NLEContext";
import { AssetPreviewOverlay } from "./AssetPreviewOverlay";
import { PreviewGuides } from "../editor/PreviewGuides";
import { PreviewOverlayProvider } from "../editor/PreviewOverlayProvider";

function subscribeFullscreen(cb: () => void) {
  document.addEventListener("fullscreenchange", cb);
  return () => document.removeEventListener("fullscreenchange", cb);
}

function getFullscreenElement() {
  return document.fullscreenElement;
}

// Clear the timeline selection when a pointer lands outside the composition
// frame (clicks *inside* the frame are handled by the DOM-edit overlay).
// fallow-ignore-next-line complexity
function deselectIfPointerOutsideFrame(
  e: React.PointerEvent,
  iframe: HTMLIFrameElement | null,
  onDeselect?: (element: null) => void,
): void {
  const el = iframe?.parentElement ?? iframe;
  if (!el) return;
  const rect = el.getBoundingClientRect();
  const outside =
    e.clientX < rect.left ||
    e.clientX > rect.right ||
    e.clientY < rect.top ||
    e.clientY > rect.bottom;
  if (outside) onDeselect?.(null);
}

export interface PreviewPaneProps {
  portrait?: boolean;
  /** Slot for overlays rendered on top of the preview (cursors, highlights, etc.) */
  previewOverlay?: ReactNode;
  onSelectTimelineElement?: (element: TimelineElement | null) => void;
  onPreviewBlockDrop?: (
    blockName: string,
    position: { left: number; top: number },
  ) => Promise<void> | void;
}

// fallow-ignore-next-line complexity
export function PreviewPane({
  portrait,
  previewOverlay,
  onSelectTimelineElement,
  onPreviewBlockDrop,
}: PreviewPaneProps) {
  const mvp = useMvpEditor();
  const previewHeader = useDockHeaderSlot("preview");
  const {
    projectId,
    iframeRef,
    togglePlay,
    pause,
    seek,
    onIframeLoad,
    previewSlots,
    onShadowIframeLoad,
    onShadowReadyChange,
    onShadowError,
    setShadowIframeNode,
    resetPreviewSlots,
    compositionStack,
    handleNavigateComposition,
    setCompositionLoading,
    timelineDisabled,
    compositionLoading,
    hasLoadedOnceRef,
    previewCompositionSize,
    setPreviewCompositionSize,
  } = useNLEContext();

  const stageRefForDrop = useRef<HTMLDivElement | null>(null);
  const handleStageRef = useCallback((ref: React.RefObject<HTMLDivElement | null>) => {
    stageRefForDrop.current = ref.current;
  }, []);

  const {
    isDragOver: previewDragOver,
    handleDragEnter: handlePreviewDragEnter,
    handleDragOver: handlePreviewDragOver,
    handleDragLeave: handlePreviewDragLeave,
    handleDrop: handlePreviewDrop,
  } = usePreviewBlockDrop({
    portrait,
    compositionSize: previewCompositionSize,
    stageRef: stageRefForDrop as React.RefObject<HTMLDivElement | null>,
    onBlockDrop: onPreviewBlockDrop,
  });

  // Preview-only fullscreen: fullscreen targets THIS pane's container, so the
  // browser shows only the preview (sidebars + timeline are excluded naturally).
  const containerRef = useRef<HTMLDivElement>(null);
  const fullscreenElement = useSyncExternalStore(subscribeFullscreen, getFullscreenElement);
  const isFullscreen = fullscreenElement === containerRef.current && fullscreenElement != null;

  const toggleFullscreen = useCallback(() => {
    if (!containerRef.current) return;
    if (document.fullscreenElement) {
      void document.exitFullscreen();
    } else {
      void containerRef.current.requestFullscreen();
    }
  }, []);

  const currentLevel = compositionStack[compositionStack.length - 1];
  const directUrl = compositionStack.length > 1 ? currentLevel.previewUrl : undefined;
  const empty = useEmptyPreview(projectId, mvp && !compositionLoading && compositionStack.length === 1);

  return (
    <div
      ref={containerRef}
      // MVP insets only the canvas; the transport background reaches the panel edges.
      // Fullscreen removes the inset so the preview fills the screen.
      className={`relative scheme-dark flex-1 min-h-0 flex flex-col overflow-hidden ${mvp ? "bg-transparent" : "bg-[var(--studio-preview-bg,var(--color-neutral-950))]"} ${
        isFullscreen ? "" : mvp ? (empty ? "my-3" : "mt-3") : "m-3 rounded-md border border-border"
      }`}
      data-studio-fullscreen-target={mvp ? undefined : ""}
    >
      <div
        className={`flex-1 min-h-0 relative overflow-hidden ${mvp && !isFullscreen ? "mx-3" : ""}`}
        data-preview-pan-surface="true"
        onPointerDown={(e) =>
          deselectIfPointerOutsideFrame(e, iframeRef.current, onSelectTimelineElement)
        }
        onDragEnter={handlePreviewDragEnter}
        onDragOver={handlePreviewDragOver}
        onDragLeave={handlePreviewDragLeave}
        onDrop={handlePreviewDrop}
      >
        <div className="absolute inset-0 overflow-hidden">
          <NLEPreview
            zoomControlsTarget={mvp && !isFullscreen ? previewHeader : null}
            projectId={projectId}
            iframeRef={iframeRef}
            onIframeLoad={onIframeLoad}
            previewSlots={previewSlots}
            onShadowIframeLoad={onShadowIframeLoad}
            onShadowReadyChange={onShadowReadyChange}
            onShadowError={onShadowError}
            setShadowIframeNode={setShadowIframeNode}
            resetPreviewSlots={resetPreviewSlots}
            onCompositionLoadingChange={setCompositionLoading}
            portrait={portrait}
            directUrl={directUrl}
            suppressLoadingOverlay={hasLoadedOnceRef.current}
            onStageRef={handleStageRef}
            onCompositionSizeChange={setPreviewCompositionSize}
          />
          {previewDragOver && (
            <div className="absolute inset-2 z-40 rounded-lg border-2 border-dashed border-studio-accent/50 bg-studio-accent/4 pointer-events-none" />
          )}
          {!mvp && <AssetPreviewOverlay />}
        </div>
        {!empty && <PreviewOverlayProvider>
          <PreviewGuides />
          {!isFullscreen && previewOverlay}
        </PreviewOverlayProvider>}
        {empty && <PreviewEmptyState />}
      </div>
      {/* The MVP transport fills both side edges and the bottom inset. */}
      {!empty && <div data-preview-transport="" className={`shrink-0 ${mvp ? "bg-[var(--studio-preview-bg,var(--color-neutral-950))] py-1.5" : ""}`}>
        {!mvp && !isFullscreen && compositionStack.length > 1 && (
          <CompositionBreadcrumb stack={compositionStack} onNavigate={handleNavigateComposition} />
        )}
        <PlayerControls
          onTogglePlay={togglePlay}
          onSeek={seek}
          disabled={timelineDisabled}
          isFullscreen={isFullscreen}
          onToggleFullscreen={mvp ? undefined : toggleFullscreen}
        />
      </div>
      }
      {mvp && <AssetPreviewOverlay modal onOpen={pause} />}
    </div>
  );
}