Skip to content

🎥 Make videos programmatically with React

7.0 KB
Raw Blame
import {CanvasInternals} from '@remotion/sdk';
import type {_InternalTypes, StaticFile, TFolder} from 'remotion';
import type {CompositionSelectorItemType} from '../components/CompositionSelectorItem';
import {openFolderKey} from './persist-open-folders';

const {sortItemsByCommitOrder} = CanvasInternals;

export type AssetFolder = {
	name: string;
	items: AssetStructure;
	expanded: boolean;
};

export type AssetStructure = {
	files: StaticFile[];
	folders: AssetFolder[];
};

export const buildAssetFolderStructure = (
	files: StaticFile[],
	parentFolderName: string | null,
	foldersExpanded: Record<string, boolean>,
): AssetStructure => {
	const notInFolder = files.filter((f) => !f.name.includes('/'));
	const inFolder = files.filter((f) => f.name.includes('/'));
	const groupedByFolder: {[key: string]: StaticFile[]} = {};
	for (const item of inFolder) {
		const folderName = item.name.split('/')[0];
		if (!groupedByFolder[folderName]) {
			groupedByFolder[folderName] = [];
		}

		groupedByFolder[folderName].push(item);
	}

	return {
		files: notInFolder,
		folders: Object.keys(groupedByFolder).map((folderName) => {
			const filesInFolder = groupedByFolder[folderName];
			const filesWithoutFolderName = filesInFolder.map((f): StaticFile => {
				return {
					...f,
					name: f.name.substring(folderName.length + 1),
				};
			});

			const key = [parentFolderName, folderName].filter(Boolean).join('/');
			const isExpanded = foldersExpanded[key] ?? false;

			return {
				name: folderName,
				items: buildAssetFolderStructure(
					filesWithoutFolderName,
					[parentFolderName, folderName].filter(Boolean).join('/'),
					foldersExpanded,
				),
				expanded: isExpanded,
			};
		}),
	};
};

export const splitParentIntoNameAndParent = (
	name: string | null,
): {name: string | null; parent: string | null} => {
	if (name === null) {
		return {
			name: null,
			parent: null,
		};
	}

	const splitted = name.split('/');
	const lastName = splitted[splitted.length - 1];
	const parentParentArray = splitted.slice(0, splitted.length - 1);
	const parentParent =
		parentParentArray.length === 0 ? null : parentParentArray.join('/');

	return {
		name: lastName,
		parent: parentParent,
	};
};

/**
 * Returns storage keys for the composition folder and each ancestor, so the
 * tree can be expanded when navigating to a nested composition.
 */
export const getKeysToExpand = (
	initialFolderName: string,
	parentFolderName: string | null,
	initial: string[] = [],
): string[] => {
	initial.push(
		openFolderKey({
			folderName: initialFolderName,
			parentName: parentFolderName,
		}),
	);

	const {name, parent} = splitParentIntoNameAndParent(parentFolderName);
	if (!name) {
		return initial;
	}

	return getKeysToExpand(name, parent, initial);
};

const doesFolderExist = (
	items: CompositionSelectorItemType[],
	folderName: string,
	parentName: string | null,
): CompositionSelectorItemType[] | false => {
	for (const item of items) {
		if (item.type === 'folder') {
			if (item.folderName === folderName && item.parentName === parentName) {
				return item.items;
			}

			const found = doesFolderExist(item.items, folderName, parentName);
			if (found !== false) {
				return found;
			}
		}
	}

	return false;
};

const findItemListToPush = (
	items: CompositionSelectorItemType[],
	folderName: string | null,
	parentName: string | null,
): CompositionSelectorItemType[] => {
	if (folderName === null) {
		return items;
	}

	const folder = doesFolderExist(items, folderName, parentName);
	if (!folder) {
		// eslint-disable-next-line no-console
		console.log({items, folderName, parentName});
		throw new Error('did not find folder ' + folderName);
	}

	return folder;
};

const createFolderIfDoesNotExist = (
	items: CompositionSelectorItemType[],
	availableFolders: TFolder[],
	folderItem: TFolder,
	foldersExpanded: Record<string, boolean>,
) => {
	if (doesFolderExist(items, folderItem.name, folderItem.parent)) {
		return;
	}

	const splitted = splitParentIntoNameAndParent(folderItem.parent);
	if (folderItem.parent) {
		const parent = availableFolders.find(
			(f) => f.name === splitted.name && f.parent === splitted.parent,
		);
		if (!parent) {
			throw new Error('unexpectedly did not have parent');
		}

		createFolderIfDoesNotExist(
			items,
			availableFolders,
			parent,
			foldersExpanded,
		);
	}

	const itemList = findItemListToPush(items, splitted.name, splitted.parent);
	if (!itemList) {
		throw new Error('why did folder not exist? ' + folderItem.name);
	}

	itemList.push({
		type: 'folder',
		folder: folderItem,
		folderName: folderItem.name,
		items: [],
		key: folderItem.name,
		expanded:
			foldersExpanded[
				openFolderKey({
					folderName: folderItem.name,
					parentName: folderItem.parent,
				})
			] ?? false,
		parentName: folderItem.parent,
	});
};

export const createFolderTree = (
	comps: _InternalTypes['AnyComposition'][],
	folders: TFolder[],
	foldersExpanded: Record<string, boolean>,
): CompositionSelectorItemType[] => {
	const items: CompositionSelectorItemType[] = [];
	const uniqueFolderKeys: string[] = [];
	for (const folder of folders) {
		const folderKey = openFolderKey({
			folderName: folder.name,
			parentName: folder.parent,
		});
		if (uniqueFolderKeys.includes(folderKey)) {
			if (folder.parent) {
				throw new Error(
					`Multiple folders with the name ${folder.name} inside the folder ${folder.parent} exist. Folder names must be unique.`,
				);
			}

			throw new Error(
				'Multiple folders with the name ' +
					folder.name +
					' exist. Folder names must be unique.',
			);
		}

		uniqueFolderKeys.push(folderKey);
		createFolderIfDoesNotExist(items, folders, folder, foldersExpanded);
	}

	for (const item of comps) {
		const toPush: CompositionSelectorItemType = {
			type: 'composition',
			composition: item,
			key: item.id,
		};
		const list = findItemListToPush(
			items,
			item.folderName,
			item.parentFolderName,
		);
		list.push(toPush);
	}

	const sortTreeItems = (
		treeItems: CompositionSelectorItemType[],
	): CompositionSelectorItemType[] => {
		return sortItemsByCommitOrder(treeItems, (item) =>
			item.type === 'folder' ? item.folder.order : item.composition.order,
		).map((item) => {
			if (item.type === 'composition') {
				return item;
			}

			return {
				...item,
				items: sortTreeItems(item.items),
			};
		});
	};

	return sortTreeItems(items);
};

/**
 * Sorts the tree returned by createFolderTree by name, on every level.
 * Folders stay grouped above compositions, and both groups are sorted.
 */
export const sortFolderTreeAlphabetically = (
	items: CompositionSelectorItemType[],
): CompositionSelectorItemType[] => {
	return items
		.map((item) => {
			if (item.type !== 'folder') {
				return item;
			}

			return {...item, items: sortFolderTreeAlphabetically(item.items)};
		})
		.sort((a, b) => {
			if (a.type !== b.type) {
				return a.type === 'folder' ? -1 : 1;
			}

			const aName = a.type === 'folder' ? a.folderName : a.composition.id;
			const bName = b.type === 'folder' ? b.folderName : b.composition.id;

			// `numeric` so that Scene2 comes before Scene10.
			return aName.localeCompare(bName, undefined, {numeric: true});
		});
};