Skip to content

🎥 Make videos programmatically with React

5.6 KB
Raw Blame
import {PlayerInternals} from '@remotion/player';
import {useCallback, useEffect, useMemo, useRef, useState} from 'react';
import ReactDOM from 'react-dom';
import {WHITE} from '../helpers/colors';
import {useMobileLayout} from '../helpers/mobile-layout';
import {noop} from '../helpers/noop';
import {HigherZIndex, useZIndex} from '../state/z-index';
import {InlineAction, type InlineActionProps} from './InlineAction';
import {
	getNextMenuTreeId,
	isNodeInMenuTree,
	MenuTreeContext,
} from './Menu/menu-tree-context';
import {getPortal} from './Menu/portals';
import {
	MAX_MENU_WIDTH,
	MAX_MOBILE_MENU_WIDTH,
	fullScreenOverlay,
	menuContainerTowardsTop,
	outerPortal,
} from './Menu/styles';
import type {ComboboxValue} from './NewComposition/ComboBox';
import {MenuContent} from './NewComposition/MenuContent';

// Some duplicate state with ContextMenu.tsx

type OpenState =
	| {
			type: 'not-open';
	  }
	| {
			type: 'open';
			left: number;
			top: number;
			values: ComboboxValue[] | null;
	  };

const container: React.CSSProperties = {
	display: 'flex',
	height: 24,
};

const InlineDropdownMenu = ({
	triggerRef,
	opened,
	values,
	menuTreeId,
	currentZIndex,
	onHide,
}: {
	readonly triggerRef: React.RefObject<HTMLDivElement | null>;
	readonly opened: Extract<OpenState, {type: 'open'}>;
	readonly values: ComboboxValue[];
	readonly menuTreeId: number;
	readonly currentZIndex: number;
	readonly onHide: () => void;
}) => {
	const size = PlayerInternals.useElementSize(triggerRef, {
		triggerOnWindowResize: true,
		shouldApplyCssTransforms: true,
	});

	const isMobileLayout = useMobileLayout();

	const spaceToBottom = useMemo(() => {
		if (size) {
			return size.windowSize.height - opened.top;
		}

		return 0;
	}, [opened, size]);

	const spaceToTop = useMemo(() => {
		if (size) {
			return opened.top;
		}

		return 0;
	}, [opened, size]);

	const portalStyle = useMemo(() => {
		if (!size) {
			return;
		}

		const spaceToRight = size.windowSize.width - size.left;
		const spaceToLeft = size.left + size.width;

		const minSpaceRequired = isMobileLayout
			? MAX_MOBILE_MENU_WIDTH
			: MAX_MENU_WIDTH;

		const verticalLayout = spaceToTop > spaceToBottom ? 'bottom' : 'top';
		const canOpenOnLeft = spaceToLeft >= minSpaceRequired;
		const canOpenOnRight = spaceToRight >= minSpaceRequired;
		const horizontalLayout = canOpenOnRight ? 'left' : 'right';

		return {
			...menuContainerTowardsTop,
			...(verticalLayout === 'top'
				? {
						top: opened.top,
					}
				: {
						bottom: size.windowSize.height - opened.top,
					}),
			...(horizontalLayout === 'left'
				? {
						left: opened.left,
					}
				: {
						right: canOpenOnLeft ? size.windowSize.width - opened.left : 0,
					}),
		};
	}, [opened, size, isMobileLayout, spaceToTop, spaceToBottom]);

	if (!portalStyle) {
		return null;
	}

	return ReactDOM.createPortal(
		<div style={fullScreenOverlay}>
			<div style={outerPortal} className="css-reset">
				<HigherZIndex onOutsideClick={onHide} onEscape={onHide}>
					<div
						data-remotion-menu-tree-id={menuTreeId}
						style={portalStyle}
						onPointerDown={(event) => event.stopPropagation()}
					>
						<MenuTreeContext.Provider value={menuTreeId}>
							<MenuContent
								onNextMenu={noop}
								onPreviousMenu={noop}
								values={values}
								onHide={onHide}
								leaveLeftSpace
								preselectIndex={false}
								topItemCanBeUnselected={false}
								fixedHeight={null}
							/>
						</MenuTreeContext.Provider>
					</div>
				</HigherZIndex>
			</div>
		</div>,
		getPortal(currentZIndex),
	);
};

export const InlineDropdown = ({
	values,
	getItems,
	onOpenChange,
	unhoveredColor,
	...props
}: Omit<InlineActionProps, 'onClick'> & {
	readonly values?: ComboboxValue[];
	readonly getItems?: () => ComboboxValue[];
	readonly onOpenChange?: (open: boolean) => void;
}) => {
	const ref = useRef<HTMLDivElement>(null);
	const [menuTreeId] = useState(getNextMenuTreeId);
	const [opened, setOpened] = useState<OpenState>({type: 'not-open'});

	const {currentZIndex} = useZIndex();

	const onClick: React.MouseEventHandler<HTMLButtonElement> = useCallback(
		(e) => {
			e.preventDefault();
			e.stopPropagation();
			const invocationValues = getItems?.() ?? values ?? [];
			if (invocationValues.length === 0) {
				return;
			}

			setOpened({
				type: 'open',
				left: e.clientX,
				top: e.clientY,
				values: invocationValues,
			});
			onOpenChange?.(true);
		},
		[getItems, onOpenChange, values],
	);

	const onHide = useCallback(() => {
		setOpened({type: 'not-open'});
		onOpenChange?.(false);
	}, [onOpenChange]);

	useEffect(() => {
		if (opened.type === 'not-open') {
			return;
		}

		const dismissWithoutClickThrough = (event: PointerEvent) => {
			if (event.button !== 0) {
				return;
			}

			const target = event.target as Node;
			if (isNodeInMenuTree(target, menuTreeId)) {
				return;
			}

			event.preventDefault();
			event.stopPropagation();
			event.stopImmediatePropagation();
			onHide();
		};

		window.addEventListener('pointerdown', dismissWithoutClickThrough, true);
		return () => {
			window.removeEventListener(
				'pointerdown',
				dismissWithoutClickThrough,
				true,
			);
		};
	}, [menuTreeId, onHide, opened.type]);

	return (
		<>
			<div ref={ref} style={container}>
				<InlineAction
					onClick={onClick}
					unhoveredColor={opened.type === 'open' ? WHITE : unhoveredColor}
					{...props}
					aria-expanded={opened.type === 'open'}
				/>
			</div>
			{opened.type === 'open' ? (
				<InlineDropdownMenu
					triggerRef={ref}
					opened={opened}
					values={opened.values ?? values ?? []}
					menuTreeId={menuTreeId}
					currentZIndex={currentZIndex}
					onHide={onHide}
				/>
			) : null}
		</>
	);
};