Skip to content

🎥 Make videos programmatically with React

4.0 KB
Raw Blame
import {PlayerInternals} from '@remotion/player';
import React, {
	useContext,
	useLayoutEffect,
	useMemo,
	useRef,
	useState,
} from 'react';
import {useTimelineFlex} from '../../state/timeline';
import type {
	SplitterDragState,
	SplitterOrientation,
	TSplitterContext,
} from './SplitterContext';
import {
	getSplitterFlexBounds,
	SplitterContext,
	SplitterLayoutContext,
} from './SplitterContext';
import {SPLITTER_HANDLE_SIZE} from './SplitterHandle';

const containerRow: React.CSSProperties = {
	display: 'flex',
	flexDirection: 'row',
	flex: 1,
	height: '100%',
	width: '100%',
};

export const containerColumn: React.CSSProperties = {
	display: 'flex',
	flexDirection: 'column',
	flex: 1,
	height: 0,
};

export const SplitterContainer: React.FC<{
	readonly orientation: SplitterOrientation;
	readonly maxFlex: number;
	readonly minFlex: number;
	readonly maxFlexerSize: number | null;
	readonly minFlexerSize: number | null;
	readonly maxAntiFlexerSize: number | null;
	readonly minAntiFlexerSize: number | null;
	readonly id: string;
	readonly defaultFlex: number;
	readonly children: React.ReactNode;
}> = ({
	orientation,
	children,
	defaultFlex,
	maxFlex,
	minFlex,
	maxFlexerSize,
	minFlexerSize,
	maxAntiFlexerSize,
	minAntiFlexerSize,
	id,
}) => {
	const parentLayout = useContext(SplitterLayoutContext);
	const [initialTimelineFlex, persistFlex] = useTimelineFlex(id);
	const [flexValue, setFlexValue] = useState(
		initialTimelineFlex ?? defaultFlex,
	);

	const [collapsedDuringDrag, setCollapsedDuringDrag] = useState<
		'left' | 'right' | null
	>(null);

	const ref = useRef<HTMLDivElement>(null);
	const isDragging = useRef<SplitterDragState>(false);
	const size = PlayerInternals.useElementSize(ref, {
		triggerOnWindowResize: true,
		shouldApplyCssTransforms: true,
	});
	const availableSize = size
		? (orientation === 'vertical' ? size.width : size.height) -
			SPLITTER_HANDLE_SIZE
		: null;
	const flexBounds = getSplitterFlexBounds({
		availableSize,
		maxAntiFlexerSize,
		maxFlex,
		maxFlexerSize,
		minAntiFlexerSize,
		minFlex,
		minFlexerSize,
	});
	let effectiveFlexValue = Math.min(
		flexBounds.maxFlex,
		Math.max(flexBounds.minFlex, flexValue),
	);
	if (availableSize !== null && availableSize > 0) {
		// Keep panel boundaries on whole pixels so toolbar icons stay crisp.
		const minimumSize = Math.ceil(flexBounds.minFlex * availableSize);
		const maximumSize = Math.floor(flexBounds.maxFlex * availableSize);
		if (minimumSize <= maximumSize) {
			effectiveFlexValue =
				Math.min(
					maximumSize,
					Math.max(minimumSize, Math.round(flexValue * availableSize)),
				) / availableSize;
		}
	}

	const value: TSplitterContext = useMemo(() => {
		return {
			flexValue: effectiveFlexValue,
			collapsedDuringDrag,
			setCollapsedDuringDrag,
			ref,
			setFlexValue,
			isDragging,
			orientation,
			id,
			maxFlex,
			minFlex,
			maxFlexerSize,
			minFlexerSize,
			maxAntiFlexerSize,
			minAntiFlexerSize,
			defaultFlex,
			persistFlex,
		};
	}, [
		defaultFlex,
		collapsedDuringDrag,
		effectiveFlexValue,
		id,
		maxFlex,
		maxFlexerSize,
		minFlexerSize,
		maxAntiFlexerSize,
		minAntiFlexerSize,
		minFlex,
		orientation,
		persistFlex,
		ref,
	]);

	const childCount = React.Children.toArray(children).length;
	const layout = useMemo(
		() => ({
			parentLayout,
			effectiveFlexValue,
			collapsedDuringDrag,
			orientation,
			width: size?.width,
			height: size?.height,
			childCount,
		}),
		[
			parentLayout,
			effectiveFlexValue,
			collapsedDuringDrag,
			orientation,
			size?.width,
			size?.height,
			childCount,
		],
	);
	const refreshSize = size?.refresh;

	useLayoutEffect(() => {
		// Remeasure this splitter when its own or an ancestor's layout changes.
		refreshSize?.();
	}, [layout, refreshSize]);

	return (
		<SplitterLayoutContext.Provider value={layout}>
			<SplitterContext.Provider value={value}>
				<div
					ref={ref}
					style={orientation === 'horizontal' ? containerColumn : containerRow}
				>
					{children}
				</div>
			</SplitterContext.Provider>
		</SplitterLayoutContext.Provider>
	);
};