Skip to content

🎥 Make videos programmatically with React

Add composition and folder reordering

Jonny Burgerf18b63ea140c
diff --git a/packages/browser-studio/src/browser-studio-operations.ts b/packages/browser-studio/src/browser-studio-operations.ts
index 21e307f160..0365bdfca0 100644
--- a/packages/browser-studio/src/browser-studio-operations.ts
+++ b/packages/browser-studio/src/browser-studio-operations.ts
@@ -235,6 +235,13 @@ const getCodemodTargetCompositionId = (
return codemod.idToMove;
}
+ if (
+ codemod.type === 'move-composition-or-folder' &&
+ codemod.source.type === 'composition'
+ ) {
+ return codemod.source.compositionId;
+ }
+
return null;
};
@@ -276,6 +283,21 @@ const resolveCodemodTargetFile = ({
return findProjectFile({filePath: folderFile, project});
}
+ if (
+ codemod.type === 'move-composition-or-folder' &&
+ codemod.source.type === 'folder'
+ ) {
+ const folderFile = getFolderFile({
+ folderName: codemod.source.folderName,
+ project,
+ });
+ if (folderFile === null) {
+ throw new Error(`Could not find folder "${codemod.source.folderName}"`);
+ }
+
+ return findProjectFile({filePath: folderFile, project});
+ }
+
const rootFile = getRootFileForProject({
entryPoint: project.entryPoint,
project,
diff --git a/packages/example/e2e/studio.test.mts b/packages/example/e2e/studio.test.mts
index 7651758513..d9d71e64e9 100644
--- a/packages/example/e2e/studio.test.mts
+++ b/packages/example/e2e/studio.test.mts
@@ -7,6 +7,7 @@ import {
effectKeyframeE2eFile,
exampleDir,
lostNodePathE2eFile,
+ rootFile,
} from './constants.mts';
import {
navigateToLostNodePathE2e,
@@ -29,6 +30,81 @@ const outlineSelectionCasesFile = path.join(
'OutlineSelectionCases.tsx',
);
+const dragCompositionSelectorItem = async ({
+ page,
+ sourceTitle,
+ targetTitle,
+ position,
+ drop,
+}: {
+ page: Page;
+ sourceTitle: string;
+ targetTitle: string;
+ position: 'before' | 'inside' | 'after';
+ drop: boolean;
+}) => {
+ return page.evaluate(
+ ({
+ sourceTitle: source,
+ targetTitle: target,
+ position: dropPosition,
+ drop: shouldDrop,
+ }) => {
+ const items = Array.from(
+ document.querySelectorAll<HTMLElement>(
+ '.__remotion-composition-selector-item',
+ ),
+ );
+ const sourceElement = items.find((element) => element.title === source);
+ const targetElement = items.find((element) => element.title === target);
+ if (!sourceElement || !targetElement) {
+ throw new Error(
+ `Could not find drag source ${source} or target ${target}`,
+ );
+ }
+
+ const dataTransfer = new DataTransfer();
+ sourceElement.dispatchEvent(
+ new DragEvent('dragstart', {
+ bubbles: true,
+ cancelable: true,
+ dataTransfer,
+ }),
+ );
+ const rect = targetElement.getBoundingClientRect();
+ const clientY =
+ dropPosition === 'before'
+ ? rect.top + 1
+ : dropPosition === 'after'
+ ? rect.bottom - 1
+ : rect.top + rect.height / 2;
+ const dragOver = new DragEvent('dragover', {
+ bubbles: true,
+ cancelable: true,
+ clientY,
+ dataTransfer,
+ });
+ targetElement.dispatchEvent(dragOver);
+ if (shouldDrop) {
+ targetElement.dispatchEvent(
+ new DragEvent('drop', {
+ bubbles: true,
+ cancelable: true,
+ clientY,
+ dataTransfer,
+ }),
+ );
+ sourceElement.dispatchEvent(
+ new DragEvent('dragend', {bubbles: true, dataTransfer}),
+ );
+ }
+
+ return dragOver.defaultPrevented;
+ },
+ {sourceTitle, targetTitle, position, drop},
+ );
+};
+
const dropAssetOnCanvas = async ({
assetPath,
durationInSeconds,
@@ -1118,6 +1194,166 @@ test.describe('visual mode', () => {
await expect(page).toHaveURL(/timeline-virtualization-testbed/);
});
+ test('should visually reorder and nest compositions and folders', async ({
+ page,
+ }) => {
+ test.setTimeout(60_000);
+ const initialContents = fs.readFileSync(rootFile, 'utf8');
+ await page.goto(STUDIO_URL);
+ await expect(
+ page.getByTitle('AnimatedBarChart', {exact: true}),
+ ).toBeVisible({
+ timeout: 15_000,
+ });
+ const firstItemTitle = await page
+ .locator('.__remotion-composition-selector-item')
+ .first()
+ .getAttribute('title');
+ expect(firstItemTitle).not.toBeNull();
+ const beforeNoOpDrags = fs.readFileSync(rootFile, 'utf8');
+ expect(
+ await dragCompositionSelectorItem({
+ page,
+ sourceTitle: firstItemTitle!,
+ targetTitle: firstItemTitle!,
+ position: 'before',
+ drop: true,
+ }),
+ ).toBe(false);
+ expect(
+ await dragCompositionSelectorItem({
+ page,
+ sourceTitle: firstItemTitle!,
+ targetTitle: firstItemTitle!,
+ position: 'after',
+ drop: true,
+ }),
+ ).toBe(false);
+ await expect(page.locator('[data-composition-reorder-line]')).toHaveCount(
+ 0,
+ );
+ await page.waitForTimeout(250);
+ expect(fs.readFileSync(rootFile, 'utf8')).toBe(beforeNoOpDrags);
+
+ expect(
+ await dragCompositionSelectorItem({
+ page,
+ sourceTitle: 'AnimatedBarChart',
+ targetTitle: 'Schema',
+ position: 'before',
+ drop: false,
+ }),
+ ).toBe(true);
+ const reorderLine = page.locator('[data-composition-reorder-line]');
+ await expect(reorderLine).toBeVisible();
+ await expect(reorderLine).toHaveCSS('height', '2px');
+ await expect(reorderLine).toHaveCSS(
+ 'background-color',
+ 'rgb(11, 132, 255)',
+ );
+ const lineBox = await reorderLine.boundingBox();
+ const targetBox = await page
+ .getByTitle('Schema', {exact: true})
+ .boundingBox();
+ expect(lineBox).not.toBeNull();
+ expect(targetBox).not.toBeNull();
+ expect(Math.abs(lineBox!.y - targetBox!.y)).toBeLessThanOrEqual(2);
+ expect(lineBox!.width).toBeGreaterThan(targetBox!.width);
+
+ await dragCompositionSelectorItem({
+ page,
+ sourceTitle: 'AnimatedBarChart',
+ targetTitle: 'Schema',
+ position: 'before',
+ drop: true,
+ });
+ await expect
+ .poll(() => {
+ const contents = fs.readFileSync(rootFile, 'utf8');
+ return (
+ contents.indexOf('id="AnimatedBarChart"') <
+ contents.indexOf('<Folder name="Schema">')
+ );
+ })
+ .toBe(true);
+ const afterCompositionReorder = fs.readFileSync(rootFile, 'utf8');
+ await expect
+ .poll(async () => {
+ const compositionBox = await page
+ .getByTitle('AnimatedBarChart', {exact: true})
+ .boundingBox();
+ const folderBox = await page
+ .getByTitle('Schema', {exact: true})
+ .boundingBox();
+ return (
+ compositionBox !== null &&
+ folderBox !== null &&
+ compositionBox.y < folderBox.y
+ );
+ })
+ .toBe(true);
+ expect(
+ await dragCompositionSelectorItem({
+ page,
+ sourceTitle: 'AnimatedBarChart',
+ targetTitle: 'Schema',
+ position: 'before',
+ drop: true,
+ }),
+ ).toBe(false);
+ await page.waitForTimeout(250);
+ expect(fs.readFileSync(rootFile, 'utf8')).toBe(afterCompositionReorder);
+
+ await dragCompositionSelectorItem({
+ page,
+ sourceTitle: 'Schema',
+ targetTitle: 'use-current-scale-on-load',
+ position: 'before',
+ drop: true,
+ });
+ await expect
+ .poll(() => {
+ const contents = fs.readFileSync(rootFile, 'utf8');
+ return (
+ contents.indexOf('<Folder name="Schema">') <
+ contents.indexOf('id="use-current-scale-on-load"')
+ );
+ })
+ .toBe(true);
+ const afterFolderReorder = fs.readFileSync(rootFile, 'utf8');
+
+ await dragCompositionSelectorItem({
+ page,
+ sourceTitle: 'AnimatedBarChart',
+ targetTitle: 'Schema',
+ position: 'inside',
+ drop: true,
+ });
+ await expect
+ .poll(() => {
+ const contents = fs.readFileSync(rootFile, 'utf8');
+ const folderStart = contents.indexOf('<Folder name="Schema">');
+ const folderEnd = contents.indexOf('</Folder>', folderStart);
+ const composition = contents.indexOf('id="AnimatedBarChart"');
+ return composition > folderStart && composition < folderEnd;
+ })
+ .toBe(true);
+
+ const undoButton = page.getByRole('button', {name: /^Undo/});
+ await undoButton.click();
+ await expect
+ .poll(() => fs.readFileSync(rootFile, 'utf8'))
+ .toBe(afterFolderReorder);
+ await undoButton.click();
+ await expect
+ .poll(() => fs.readFileSync(rootFile, 'utf8'))
+ .toBe(afterCompositionReorder);
+ await undoButton.click();
+ await expect
+ .poll(() => fs.readFileSync(rootFile, 'utf8'))
+ .toBe(initialContents);
+ });
+
test('should play when a composition in the sidebar is focused', async ({
page,
}) => {
diff --git a/packages/studio-codemods/src/recast-mods.ts b/packages/studio-codemods/src/recast-mods.ts
index f5bedadaed..8c971a8045 100644
--- a/packages/studio-codemods/src/recast-mods.ts
+++ b/packages/studio-codemods/src/recast-mods.ts
@@ -18,7 +18,7 @@ import type {
VariableDeclaration,
VariableDeclarator,
} from '@babel/types';
-import type {RecastCodemod} from '@remotion/studio-shared';
+import type {CompositionOrFolder, RecastCodemod} from '@remotion/studio-shared';
import * as recast from 'recast';
import {applyVisualControl} from './apply-visual-control';
import {deleteJsxElementAtPath} from './delete-jsx-node';
@@ -53,6 +53,14 @@ export const applyCodemod = ({
});
}
+ if (codeMod.type === 'move-composition-or-folder') {
+ return moveCompositionOrFolder({
+ file,
+ transformation: codeMod,
+ changesMade,
+ });
+ }
+
const body = file.program.body.map((node) => {
return mapAll(node, codeMod, changesMade, null);
});
@@ -436,11 +444,11 @@ const getChildFolderParentName = ({
return [parentFolderName, folderName].filter(Boolean).join('/');
};
-const appendCompositionToFolder = ({
- compositionElement,
+const appendElementToFolder = ({
+ element,
folderElement,
}: {
- compositionElement: JSXElement;
+ element: JSXElement;
folderElement: JSXElement;
}) => {
folderElement.openingElement.selfClosing = false;
@@ -448,14 +456,14 @@ const appendCompositionToFolder = ({
type: 'JSXClosingElement',
name: folderElement.openingElement.name,
};
- folderElement.children.push(stripParenthesizedExtra(compositionElement));
+ folderElement.children.push(stripParenthesizedExtra(element));
};
-const appendCompositionToRoot = ({
- compositionElement,
+const appendElementToRoot = ({
+ element,
file,
}: {
- compositionElement: JSXElement;
+ element: JSXElement;
file: File;
}) => {
let appended = false;
@@ -474,12 +482,12 @@ const appendCompositionToRoot = ({
if (argument.type === 'JSXFragment') {
(argument.children as JSXFragment['children']).push(
- stripParenthesizedExtra(compositionElement),
+ stripParenthesizedExtra(element),
);
} else {
astPath.node.argument = wrapInJsxFragment([
argument as unknown as JSXElement,
- compositionElement,
+ element,
]) as never;
}
@@ -493,6 +501,247 @@ const appendCompositionToRoot = ({
}
};
+const getCompositionOrFolderLabel = (item: CompositionOrFolder) => {
+ return item.type === 'composition'
+ ? `composition "${item.compositionId}"`
+ : `folder "${[item.parentName, item.folderName].filter(Boolean).join('/')}"`;
+};
+
+const matchesCompositionOrFolder = ({
+ item,
+ node,
+ parentFolderName,
+}: {
+ item: CompositionOrFolder;
+ node: JSXElement;
+ parentFolderName: string | null;
+}) => {
+ if (item.type === 'composition') {
+ return getCompositionIdFromJSXElement(node) === item.compositionId;
+ }
+
+ return (
+ getFolderNameFromJSXElement(node) === item.folderName &&
+ parentFolderName === item.parentName
+ );
+};
+
+const moveCompositionOrFolder = ({
+ file,
+ transformation,
+ changesMade,
+}: {
+ file: File;
+ transformation: Extract<RecastCodemod, {type: 'move-composition-or-folder'}>;
+ changesMade: Change[];
+}): ApplyCodeModReturnType => {
+ type LocatedItem = {
+ node: JSXElement;
+ parent: JSXElement | JSXFragment;
+ parentFolderName: string | null;
+ path: recast.types.NodePath;
+ };
+
+ let source: LocatedItem | null = null;
+ let target: LocatedItem | null = null;
+ let destinationFolder: LocatedItem | null = null;
+ const folders: {
+ node: JSXElement;
+ name: string;
+ parentFolderName: string | null;
+ }[] = [];
+ const folderStack: string[] = [];
+
+ const visitJsxElement = (astPath: recast.types.NodePath) => {
+ const node = astPath.node as JSXElement;
+ const parent = astPath.parentPath?.node;
+ const parentFolderName = folderStack.join('/') || null;
+ const isDirectJsxChild =
+ (parent?.type === 'JSXElement' || parent?.type === 'JSXFragment') &&
+ parent.children.includes(node);
+
+ if (
+ isDirectJsxChild &&
+ matchesCompositionOrFolder({
+ item: transformation.source,
+ node,
+ parentFolderName,
+ })
+ ) {
+ source = {
+ node,
+ parent,
+ parentFolderName,
+ path: astPath,
+ };
+ }
+
+ if (
+ isDirectJsxChild &&
+ (transformation.destination.type === 'before' ||
+ transformation.destination.type === 'after') &&
+ matchesCompositionOrFolder({
+ item: transformation.destination.target,
+ node,
+ parentFolderName,
+ })
+ ) {
+ target = {
+ node,
+ parent,
+ parentFolderName,
+ path: astPath,
+ };
+ }
+
+ const folderName = getFolderNameFromJSXElement(node);
+ if (folderName !== null) {
+ folders.push({node, name: folderName, parentFolderName});
+ }
+
+ if (
+ isDirectJsxChild &&
+ transformation.destination.type === 'folder' &&
+ folderName === transformation.destination.folderName &&
+ parentFolderName === transformation.destination.parentName
+ ) {
+ destinationFolder = {
+ node,
+ parent,
+ parentFolderName,
+ path: astPath,
+ };
+ }
+
+ if (folderName !== null) {
+ folderStack.push(folderName);
+ }
+
+ for (let index = 0; index < node.children.length; index++) {
+ if (node.children[index].type === 'JSXElement') {
+ visitJsxElement(
+ astPath.get('children', index) as recast.types.NodePath,
+ );
+ }
+ }
+
+ if (folderName !== null) {
+ folderStack.pop();
+ }
+ };
+
+ recast.types.visit(file, {
+ visitJSXElement(astPath) {
+ visitJsxElement(astPath as unknown as recast.types.NodePath);
+ return false;
+ },
+ });
+
+ if (source === null) {
+ throw new Error(
+ `Could not find ${getCompositionOrFolderLabel(transformation.source)} as a direct JSX child`,
+ );
+ }
+
+ const sourceItem = source as LocatedItem;
+ if (
+ (transformation.destination.type === 'before' ||
+ transformation.destination.type === 'after') &&
+ target === null
+ ) {
+ throw new Error(
+ `Could not find ${getCompositionOrFolderLabel(transformation.destination.target)} as a reorder target`,
+ );
+ }
+
+ if (
+ transformation.destination.type === 'folder' &&
+ destinationFolder === null
+ ) {
+ const folderPath = [
+ transformation.destination.parentName,
+ transformation.destination.folderName,
+ ]
+ .filter(Boolean)
+ .join('/');
+ throw new Error(`Could not find folder "${folderPath}"`);
+ }
+
+ if (target !== null && (target as LocatedItem).node === sourceItem.node) {
+ return {newAst: file, changesMade};
+ }
+
+ const sourceFolderPath =
+ transformation.source.type === 'folder'
+ ? [transformation.source.parentName, transformation.source.folderName]
+ .filter(Boolean)
+ .join('/')
+ : null;
+ const destinationParentFolderName =
+ transformation.destination.type === 'root'
+ ? null
+ : transformation.destination.type === 'folder'
+ ? [
+ transformation.destination.parentName,
+ transformation.destination.folderName,
+ ]
+ .filter(Boolean)
+ .join('/')
+ : (target as unknown as LocatedItem).parentFolderName;
+ if (
+ sourceFolderPath !== null &&
+ destinationParentFolderName !== null &&
+ (destinationParentFolderName === sourceFolderPath ||
+ destinationParentFolderName.startsWith(`${sourceFolderPath}/`))
+ ) {
+ throw new Error('A folder cannot be moved inside itself');
+ }
+
+ if (transformation.source.type === 'folder') {
+ const sourceFolderName = transformation.source.folderName;
+ if (
+ folders.some(
+ (folder) =>
+ folder.node !== sourceItem.node &&
+ folder.name === sourceFolderName &&
+ folder.parentFolderName === destinationParentFolderName,
+ )
+ ) {
+ throw new Error(
+ `A folder named "${sourceFolderName}" already exists in the destination`,
+ );
+ }
+ }
+
+ deleteJsxElementAtPath(sourceItem.path);
+ const element = stripParenthesizedExtra(sourceItem.node);
+ if (transformation.destination.type === 'root') {
+ appendElementToRoot({element, file});
+ } else if (transformation.destination.type === 'folder') {
+ appendElementToFolder({
+ element,
+ folderElement: (destinationFolder as unknown as LocatedItem).node,
+ });
+ } else {
+ const targetItem = target as unknown as LocatedItem;
+ const targetIndex = targetItem.parent.children.indexOf(targetItem.node);
+ if (targetIndex === -1) {
+ throw new Error('The reorder target is no longer available');
+ }
+
+ targetItem.parent.children.splice(
+ transformation.destination.type === 'before'
+ ? targetIndex
+ : targetIndex + 1,
+ 0,
+ element,
+ );
+ }
+
+ changesMade.push({description: 'Moved composition or folder'});
+ return {newAst: file, changesMade};
+};
+
const moveCompositionToFolder = ({
file,
transformation,
@@ -586,15 +835,15 @@ const moveCompositionToFolder = ({
.node as JSXElement;
deleteJsxElementAtPath(sourcePath);
if (transformation.folderName === null) {
- appendCompositionToRoot({compositionElement, file});
+ appendElementToRoot({element: compositionElement, file});
changesMade.push({description: 'Moved composition to root'});
} else {
if (targetFolder === null) {
throw new Error('Could not find target folder');
}
- appendCompositionToFolder({
- compositionElement,
+ appendElementToFolder({
+ element: compositionElement,
folderElement: targetFolder,
});
changesMade.push({description: 'Moved composition into folder'});
diff --git a/packages/studio-server/src/preview-server/routes/apply-codemod.ts b/packages/studio-server/src/preview-server/routes/apply-codemod.ts
index e684532c23..39f384e962 100644
--- a/packages/studio-server/src/preview-server/routes/apply-codemod.ts
+++ b/packages/studio-server/src/preview-server/routes/apply-codemod.ts
@@ -92,6 +92,14 @@ export const getCodemodLogMessage = (
return `Moved composition "${codemod.idToMove}" ${destination}`;
}
+ if (codemod.type === 'move-composition-or-folder') {
+ const source =
+ codemod.source.type === 'composition'
+ ? `composition "${codemod.source.compositionId}"`
+ : `folder "${getFolderPath(codemod.source.parentName, codemod.source.folderName)}"`;
+ return `Moved ${source}`;
+ }
+
if (codemod.type === 'rename-folder') {
const oldName = getFolderPath(codemod.parentName, codemod.folderName);
const newName = getFolderPath(codemod.parentName, codemod.newName);
@@ -164,6 +172,18 @@ const getCodemodUndoDescription = (codemod: ApplyCodemodRequest['codemod']) => {
};
}
+ if (codemod.type === 'move-composition-or-folder') {
+ const label =
+ codemod.source.type === 'composition'
+ ? `composition "${codemod.source.compositionId}"`
+ : `folder "${getFolderPath(codemod.source.parentName, codemod.source.folderName)}"`;
+ return {
+ undoMessage: `↩️ Move of ${label}`,
+ redoMessage: `↪️ Move of ${label}`,
+ entryType: codemod.type,
+ };
+ }
+
if (codemod.type === 'new-composition') {
return {
undoMessage: `↩️ Creation of composition "${codemod.newId}"`,
diff --git a/packages/studio-server/src/preview-server/undo-stack.ts b/packages/studio-server/src/preview-server/undo-stack.ts
index f61068045a..144c8cf978 100644
--- a/packages/studio-server/src/preview-server/undo-stack.ts
+++ b/packages/studio-server/src/preview-server/undo-stack.ts
@@ -48,6 +48,7 @@ type UndoEntryType =
| 'new-composition'
| 'duplicate-composition'
| 'move-composition-to-folder'
+ | 'move-composition-or-folder'
| 'new-folder'
| 'delete-folder'
| 'rename-folder';
diff --git a/packages/studio-server/src/test/apply-codemod.test.ts b/packages/studio-server/src/test/apply-codemod.test.ts
index 8dc0e4ec9f..669d2b6f53 100644
--- a/packages/studio-server/src/test/apply-codemod.test.ts
+++ b/packages/studio-server/src/test/apply-codemod.test.ts
@@ -232,6 +232,29 @@ test('formats precise log messages for all codemods', () => {
},
expected: 'Moved composition "MoveMe" to root',
},
+ {
+ codemod: {
+ type: 'move-composition-or-folder',
+ source: {type: 'composition', compositionId: 'MoveMe'},
+ destination: {
+ type: 'before',
+ target: {type: 'folder', folderName: 'Shared', parentName: null},
+ },
+ },
+ expected: 'Moved composition "MoveMe"',
+ },
+ {
+ codemod: {
+ type: 'move-composition-or-folder',
+ source: {
+ type: 'folder',
+ folderName: 'Shared',
+ parentName: 'Parent',
+ },
+ destination: {type: 'root'},
+ },
+ expected: 'Moved folder "Parent/Shared"',
+ },
{
codemod: {
type: 'rename-folder',
@@ -960,6 +983,106 @@ test('moves a composition to root', () => {
expect(newContents.match(/id="NestedA"/g)?.length).toBe(1);
});
+test('visually reorders compositions and folders', () => {
+ const compositionBeforeFolder = parseAndApplyCodemod({
+ input: selfClosingFolderRootContents,
+ codeMod: {
+ type: 'move-composition-or-folder',
+ source: {type: 'composition', compositionId: 'KeepMe'},
+ destination: {
+ type: 'before',
+ target: {type: 'folder', folderName: 'Empty', parentName: null},
+ },
+ },
+ });
+
+ expect(compositionBeforeFolder.changesMade).toHaveLength(1);
+ expect(
+ compositionBeforeFolder.newContents.indexOf('id="KeepMe"'),
+ ).toBeLessThan(
+ compositionBeforeFolder.newContents.indexOf('<Folder name="Empty"'),
+ );
+
+ const folderAfterComposition = parseAndApplyCodemod({
+ input: selfClosingFolderRootContents,
+ codeMod: {
+ type: 'move-composition-or-folder',
+ source: {type: 'folder', folderName: 'Empty', parentName: null},
+ destination: {
+ type: 'after',
+ target: {type: 'composition', compositionId: 'KeepMe'},
+ },
+ },
+ });
+
+ expect(folderAfterComposition.changesMade).toHaveLength(1);
+ expect(
+ folderAfterComposition.newContents.indexOf('id="KeepMe"'),
+ ).toBeLessThan(
+ folderAfterComposition.newContents.indexOf('<Folder name="Empty"'),
+ );
+});
+
+test('moves a folder into another folder with its descendants', () => {
+ const {changesMade, newContents} = parseAndApplyCodemod({
+ input: folderRootContents,
+ codeMod: {
+ type: 'move-composition-or-folder',
+ source: {type: 'folder', folderName: 'Parent', parentName: null},
+ destination: {
+ type: 'folder',
+ folderName: 'Shared',
+ parentName: 'Other',
+ },
+ },
+ });
+
+ expect(changesMade).toHaveLength(1);
+ expect(newContents.match(/<Folder name="Parent">/g)).toHaveLength(1);
+ expect(newContents.match(/id="NestedA"/g)).toHaveLength(1);
+ expect(newContents.indexOf('id="NestedB"')).toBeLessThan(
+ newContents.indexOf('<Folder name="Parent">'),
+ );
+});
+
+test('rejects moving a folder into its descendant', () => {
+ expect(() =>
+ parseAndApplyCodemod({
+ input: folderRootContents,
+ codeMod: {
+ type: 'move-composition-or-folder',
+ source: {type: 'folder', folderName: 'Parent', parentName: null},
+ destination: {
+ type: 'folder',
+ folderName: 'Shared',
+ parentName: 'Parent',
+ },
+ },
+ }),
+ ).toThrow('A folder cannot be moved inside itself');
+});
+
+test('rejects duplicate folder names at the destination', () => {
+ expect(() =>
+ parseAndApplyCodemod({
+ input: folderRootContents,
+ codeMod: {
+ type: 'move-composition-or-folder',
+ source: {
+ type: 'folder',
+ folderName: 'Shared',
+ parentName: 'Parent',
+ },
+ destination: {
+ type: 'folder',
+ folderName: 'Other',
+ parentName: null,
+ },
+ },
+ }),
+ ).toThrow('A folder named "Shared" already exists in the destination');
+});
+
test('does not use folders inside JSX attributes as move targets', () => {
expect(() =>
parseAndApplyCodemod({
diff --git a/packages/studio-shared/src/codemods.ts b/packages/studio-shared/src/codemods.ts
index b67485616c..8688273d90 100644
--- a/packages/studio-shared/src/codemods.ts
+++ b/packages/studio-shared/src/codemods.ts
@@ -13,6 +13,17 @@ export type ApplyVisualControlCodemod = {
changes: VisualControlChange[];
};
+export type CompositionOrFolder =
+ | {
+ type: 'composition';
+ compositionId: string;
+ }
+ | {
+ type: 'folder';
+ folderName: string;
+ parentName: string | null;
+ };
+
export type RecastCodemod =
| {
type: 'new-composition';
@@ -66,6 +77,21 @@ export type RecastCodemod =
folderName: string | null;
parentName: string | null;
}
+ | {
+ type: 'move-composition-or-folder';
+ source: CompositionOrFolder;
+ destination:
+ | {type: 'root'}
+ | {
+ type: 'folder';
+ folderName: string;
+ parentName: string | null;
+ }
+ | {
+ type: 'before' | 'after';
+ target: CompositionOrFolder;
+ };
+ }
| {
type: 'rename-folder';
folderName: string;
diff --git a/packages/studio-shared/src/index.ts b/packages/studio-shared/src/index.ts
index a7f05eddf8..7bc7216fa9 100644
--- a/packages/studio-shared/src/index.ts
+++ b/packages/studio-shared/src/index.ts
@@ -184,7 +184,11 @@ export type {
SequenceNodePathMutation,
SequenceNodePathRemapping,
} from './sequence-node-path-mutation';
-export type {ApplyVisualControlCodemod, RecastCodemod} from './codemods';
+export type {
+ ApplyVisualControlCodemod,
+ CompositionOrFolder,
+ RecastCodemod,
+} from './codemods';
export {REACT_REFRESH_FINISHED_EVENT} from './react-refresh-event';
export {hasSequenceTimingTraits} from './has-sequence-timing-traits';
export {
diff --git a/packages/studio/src/components/CompositionSelector.tsx b/packages/studio/src/components/CompositionSelector.tsx
index e559e9978e..49d090cbe4 100644
--- a/packages/studio/src/components/CompositionSelector.tsx
+++ b/packages/studio/src/components/CompositionSelector.tsx
@@ -18,10 +18,11 @@ import {FolderContext} from '../state/folders';
import {SetSelectedModalContext} from '../state/modals';
import {useZIndex} from '../state/z-index';
import {
- compositionDragDataToSymbolicatedStack,
- getCompositionDragPreviewMetadata,
- parseCompositionDragData,
-} from './composition-drag-data';
+ type CompositionSelectorActiveDrag,
+ compositionSelectorDragDataToSymbolicatedStack,
+ hasCompositionSelectorDragData,
+ parseCompositionSelectorDragData,
+} from './composition-selector-drag-data';
import {CompositionSelectorItem} from './CompositionSelectorItem';
import {ContextMenuForTarget} from './ContextMenu';
import {useSelectComposition} from './InitialCompositionLoader';
@@ -153,6 +154,7 @@ export const CompositionSelector: React.FC = () => {
setSelectedModal,
]);
const [rootDragHovered, setRootDragHovered] = useState(false);
+ const activeDragRef = useRef<CompositionSelectorActiveDrag | null>(null);
const listRef = useRef<HTMLDivElement>(null);
const autoScrollAnimation = useRef<number | null>(null);
const autoScrollSpeed = useRef(0);
@@ -243,7 +245,7 @@ export const CompositionSelector: React.FC = () => {
(event: React.DragEvent<HTMLElement>) => {
if (
window.remotion_isReadOnlyStudio ||
- getCompositionDragPreviewMetadata(event.dataTransfer.types) === null
+ !hasCompositionSelectorDragData(event.dataTransfer.types)
) {
stopCompositionListAutoScroll();
return;
@@ -269,11 +271,19 @@ export const CompositionSelector: React.FC = () => {
const onRootDragOver = useCallback((event: React.DragEvent<HTMLElement>) => {
if (
window.remotion_isReadOnlyStudio ||
- getCompositionDragPreviewMetadata(event.dataTransfer.types) === null
+ !hasCompositionSelectorDragData(event.dataTransfer.types)
) {
return;
}
+ if (
+ activeDragRef.current === null ||
+ activeDragRef.current.parentFolderPath === null
+ ) {
+ setRootDragHovered(false);
+ return;
+ }
+
event.preventDefault();
event.dataTransfer.dropEffect = 'move';
setRootDragHovered(true);
@@ -301,8 +311,17 @@ export const CompositionSelector: React.FC = () => {
return;
}
- const compositionDragData = parseCompositionDragData(event.dataTransfer);
- if (compositionDragData === null) {
+ const dragData = parseCompositionSelectorDragData(event.dataTransfer);
+ if (dragData === null) {
+ return;
+ }
+
+ if (
+ activeDragRef.current === null ||
+ activeDragRef.current.parentFolderPath === null
+ ) {
+ event.stopPropagation();
+ setRootDragHovered(false);
return;
}
@@ -310,16 +329,8 @@ export const CompositionSelector: React.FC = () => {
event.stopPropagation();
stopCompositionListAutoScroll();
setRootDragHovered(false);
-
- const composition = compositions.find(
- (c) => c.id === compositionDragData.compositionId,
- );
- if (!composition || composition.folderName === null) {
- return;
- }
-
const notification = showNotification(
- `Moving ${compositionDragData.compositionId}...`,
+ `Moving ${dragData.item.type === 'composition' ? dragData.item.compositionId : dragData.item.folderName}...`,
null,
);
const controller = new AbortController();
@@ -327,15 +338,14 @@ export const CompositionSelector: React.FC = () => {
try {
const result = await applyCodemod({
codemod: {
- type: 'move-composition-to-folder',
- idToMove: compositionDragData.compositionId,
- folderName: null,
- parentName: null,
+ type: 'move-composition-or-folder',
+ source: dragData.item,
+ destination: {type: 'root'},
},
dryRun: false,
signal: controller.signal,
symbolicatedStack:
- compositionDragDataToSymbolicatedStack(compositionDragData),
+ compositionSelectorDragDataToSymbolicatedStack(dragData),
});
if (result.success) {
@@ -350,7 +360,7 @@ export const CompositionSelector: React.FC = () => {
);
}
},
- [compositions, stopCompositionListAutoScroll],
+ [stopCompositionListAutoScroll],
);
return (
@@ -376,7 +386,7 @@ export const CompositionSelector: React.FC = () => {
onDropCapture={stopCompositionListAutoScroll}
onDrop={onRootDrop}
>
- {items.map((c) => {
+ {items.map((c, index) => {
return (
<CompositionSelectorItem
key={c.key + c.type}
@@ -389,8 +399,13 @@ export const CompositionSelector: React.FC = () => {
selectComposition={selectComposition}
toggleFolder={toggleFolder}
clearRootDragHover={clearRootDragHover}
+ canReorder={compositionSortOrder === 'registration'}
tabIndex={tabIndex}
item={c}
+ activeDragRef={activeDragRef}
+ parentFolderPath={null}
+ previousSibling={index === 0 ? null : items[index - 1]}
+ nextSibling={index === items.length - 1 ? null : items[index + 1]}
/>
);
})}
diff --git a/packages/studio/src/components/CompositionSelectorItem.tsx b/packages/studio/src/components/CompositionSelectorItem.tsx
index cfa071d9f2..3334877f94 100644
--- a/packages/studio/src/components/CompositionSelectorItem.tsx
+++ b/packages/studio/src/components/CompositionSelectorItem.tsx
@@ -1,4 +1,10 @@
-import type {DragEvent, KeyboardEvent, MouseEvent} from 'react';
+import type {CompositionOrFolder, RecastCodemod} from '@remotion/studio-shared';
+import type {
+ DragEvent,
+ KeyboardEvent,
+ MouseEvent,
+ MutableRefObject,
+} from 'react';
import React, {
useCallback,
useContext,
@@ -12,6 +18,7 @@ import {StudioServerConnectionCtx} from '../helpers/client-id';
import {
CURRENT_COLOR,
LIGHT_TEXT,
+ TIMELINE_BLUE,
TRANSPARENT,
WHITE,
WHITE_ALPHA_06,
@@ -29,13 +36,16 @@ import {
} from '../helpers/sidebar-scroll-into-view';
import {CollapsedFolderIcon, ExpandedFolderIcon} from '../icons/folder';
import {SetSelectedModalContext} from '../state/modals';
-import {
- compositionDragDataToSymbolicatedStack,
- getCompositionDragPreviewMetadata,
- makeCompositionDragData,
- parseCompositionDragData,
-} from './composition-drag-data';
+import {makeCompositionDragData} from './composition-drag-data';
import {getCompositionContextMenuItems} from './composition-menu-items';
+import {
+ type CompositionSelectorActiveDrag,
+ compositionSelectorDragDataToSymbolicatedStack,
+ hasCompositionSelectorDragData,
+ makeCompositionSelectorDragData,
+ parseCompositionSelectorDragData,
+ type CompositionSelectorDragData,
+} from './composition-selector-drag-data';
import {CompositionContextButton} from './CompositionContextButton';
import {CompositionOrStillIcon} from './CompositionOrStillIcon';
import {ContextMenu} from './ContextMenu';
@@ -85,6 +95,98 @@ const iconStyle: React.CSSProperties = {
flexShrink: 0,
};
+const reorderWrapper: React.CSSProperties = {
+ position: 'relative',
+};
+
+const reorderLineBase: React.CSSProperties = {
+ backgroundColor: TIMELINE_BLUE,
+ height: 2,
+ left: 0,
+ pointerEvents: 'none',
+ position: 'absolute',
+ right: 0,
+ zIndex: 1,
+};
+
+type DropPosition = 'before' | 'inside' | 'after';
+
+const itemToDescriptor = (
+ item: CompositionSelectorItemType,
+): CompositionOrFolder => {
+ return item.type === 'composition'
+ ? {type: 'composition', compositionId: item.composition.id}
+ : {
+ type: 'folder',
+ folderName: item.folderName,
+ parentName: item.parentName,
+ };
+};
+
+const itemsAreEqual = (
+ left: CompositionOrFolder,
+ right: CompositionOrFolder,
+) => {
+ if (left.type === 'composition') {
+ return (
+ right.type === 'composition' && left.compositionId === right.compositionId
+ );
+ }
+
+ return (
+ right.type === 'folder' &&
+ left.folderName === right.folderName &&
+ left.parentName === right.parentName
+ );
+};
+
+const getFolderPath = ({
+ folderName,
+ parentName,
+}: {
+ readonly folderName: string;
+ readonly parentName: string | null;
+}) => {
+ return [parentName, folderName].filter(Boolean).join('/');
+};
+
+const wouldMoveFolderIntoItself = ({
+ activeDrag,
+ destinationParentFolderPath,
+}: {
+ readonly activeDrag: CompositionSelectorActiveDrag;
+ readonly destinationParentFolderPath: string | null;
+}) => {
+ if (
+ activeDrag.item.type !== 'folder' ||
+ destinationParentFolderPath === null
+ ) {
+ return false;
+ }
+
+ const sourceFolderPath = getFolderPath(activeDrag.item);
+ return (
+ destinationParentFolderPath === sourceFolderPath ||
+ destinationParentFolderPath.startsWith(`${sourceFolderPath}/`)
+ );
+};
+
+const canMoveIntoFolder = ({
+ activeDrag,
+ destinationFolderPath,
+}: {
+ readonly activeDrag: CompositionSelectorActiveDrag;
+ readonly destinationFolderPath: string;
+}) => {
+ return (
+ activeDrag.parentFolderPath !== destinationFolderPath &&
+ !wouldMoveFolderIntoItself({
+ activeDrag,
+ destinationParentFolderPath: destinationFolderPath,
+ })
+ );
+};
+
export type CompositionSelectorItemType =
| {
key: string;
@@ -114,7 +216,12 @@ export const CompositionSelectorItem: React.FC<{
parentName: string | null,
) => void;
readonly clearRootDragHover: () => void;
+ readonly canReorder: boolean;
readonly level: number;
+ readonly activeDragRef: MutableRefObject<CompositionSelectorActiveDrag | null>;
+ readonly parentFolderPath: string | null;
+ readonly previousSibling: CompositionSelectorItemType | null;
+ readonly nextSibling: CompositionSelectorItemType | null;
}> = ({
item,
level,
@@ -123,6 +230,11 @@ export const CompositionSelectorItem: React.FC<{
selectComposition,
toggleFolder,
clearRootDragHover,
+ canReorder,
+ activeDragRef,
+ parentFolderPath,
+ previousSibling,
+ nextSibling,
}) => {
const selected = useMemo(() => {
if (item.type === 'composition') {
@@ -132,7 +244,7 @@ export const CompositionSelectorItem: React.FC<{
return false;
}, [item, currentComposition]);
const [isDragging, setIsDragging] = useState(false);
- const [dragHovered, setDragHovered] = useState(false);
+ const [dropPosition, setDropPosition] = useState<DropPosition | null>(null);
const compositionRowRef = useRef<HTMLAnchorElement>(null);
const compositionId =
@@ -150,22 +262,35 @@ export const CompositionSelectorItem: React.FC<{
}, [compositionId, selected]);
const style: React.CSSProperties = useMemo(() => {
- const idleBackground = dragHovered
- ? WHITE_ALPHA_12
- : selected
- ? WHITE_ALPHA_06
- : TRANSPARENT;
+ const idleBackground =
+ dropPosition === 'inside'
+ ? WHITE_ALPHA_12
+ : selected
+ ? WHITE_ALPHA_06
+ : TRANSPARENT;
return {
...itemStyle,
...hoverableStyle({
idleBackground,
- hoverBackground: dragHovered ? WHITE_ALPHA_12 : WHITE_ALPHA_06,
+ hoverBackground:
+ dropPosition === 'inside' ? WHITE_ALPHA_12 : WHITE_ALPHA_06,
idleColor: selected ? WHITE : LIGHT_TEXT,
hoverColor: WHITE,
}),
paddingLeft: 12 + level * 8,
};
- }, [dragHovered, level, selected]);
+ }, [dropPosition, level, selected]);
+
+ const reorderLineStyle = useMemo((): React.CSSProperties | null => {
+ if (dropPosition !== 'before' && dropPosition !== 'after') {
+ return null;
+ }
+
+ return {
+ ...reorderLineBase,
+ ...(dropPosition === 'before' ? {top: -1} : {bottom: -1}),
+ };
+ }, [dropPosition]);
const onClick = useCallback(
(evt: MouseEvent<HTMLElement> | KeyboardEvent<HTMLElement>) => {
@@ -233,115 +358,185 @@ export const CompositionSelectorItem: React.FC<{
setSelectedModal,
]);
- const onCompositionDragStart = useCallback(
+ const onItemDragStart = useCallback(
(event: DragEvent<HTMLElement>) => {
- if (item.type !== 'composition' || window.remotion_isReadOnlyStudio) {
+ if (window.remotion_isReadOnlyStudio) {
event.preventDefault();
return;
}
+ const itemDescriptor = itemToDescriptor(item);
+ activeDragRef.current = {
+ item: itemDescriptor,
+ parentFolderPath,
+ };
setIsDragging(true);
event.dataTransfer.effectAllowed = 'copyMove';
- const dragData = makeCompositionDragData({
- compositionFile: resolvedLocation?.source ?? null,
- compositionId: item.composition.id,
- width: item.composition.width ?? null,
- height: item.composition.height ?? null,
- durationInFrames: item.composition.durationInFrames ?? null,
+ const selectorDragData = makeCompositionSelectorDragData({
+ item: itemDescriptor,
+ sourceFile: resolvedLocation?.source ?? null,
});
- event.dataTransfer.setData(dragData.mimeType, dragData.payload);
+ event.dataTransfer.setData(
+ selectorDragData.mimeType,
+ selectorDragData.payload,
+ );
+
+ if (item.type === 'composition') {
+ const compositionDragData = makeCompositionDragData({
+ compositionFile: resolvedLocation?.source ?? null,
+ compositionId: item.composition.id,
+ width: item.composition.width ?? null,
+ height: item.composition.height ?? null,
+ durationInFrames: item.composition.durationInFrames ?? null,
+ });
+ event.dataTransfer.setData(
+ compositionDragData.mimeType,
+ compositionDragData.payload,
+ );
+ }
},
- [item, resolvedLocation?.source],
+ [activeDragRef, item, parentFolderPath, resolvedLocation?.source],
);
- const onCompositionDragEnd = useCallback(() => {
+ const onItemDragEnd = useCallback(() => {
+ activeDragRef.current = null;
setIsDragging(false);
- }, []);
+ setDropPosition(null);
+ }, [activeDragRef]);
- const onFolderDragOver = useCallback(
- (event: DragEvent<HTMLElement>) => {
- if (
- item.type !== 'folder' ||
- window.remotion_isReadOnlyStudio ||
- getCompositionDragPreviewMetadata(event.dataTransfer.types) === null
- ) {
- return;
+ const getDropPosition = useCallback(
+ (event: DragEvent<HTMLElement>): DropPosition | null => {
+ const activeDrag = activeDragRef.current;
+ if (activeDrag === null) {
+ return null;
}
- event.preventDefault();
- event.stopPropagation();
- event.dataTransfer.dropEffect = 'move';
- clearRootDragHover();
- setDragHovered(true);
- },
- [clearRootDragHover, item],
- );
+ if (!canReorder) {
+ if (item.type !== 'folder') {
+ return null;
+ }
- const onFolderDragLeave = useCallback(() => {
- setDragHovered(false);
- }, []);
+ return canMoveIntoFolder({
+ activeDrag,
+ destinationFolderPath: getFolderPath(item),
+ })
+ ? 'inside'
+ : null;
+ }
+
+ const {top, height} = event.currentTarget.getBoundingClientRect();
+ const progress = height === 0 ? 0.5 : (event.clientY - top) / height;
+ const position =
+ item.type === 'composition'
+ ? progress < 0.5
+ ? 'before'
+ : 'after'
+ : progress < 0.25
+ ? 'before'
+ : progress > 0.75
+ ? 'after'
+ : 'inside';
+ const target = itemToDescriptor(item);
+ if (itemsAreEqual(activeDrag.item, target)) {
+ return null;
+ }
- const onFolderChildListDragOver = useCallback(
- (event: DragEvent<HTMLElement>) => {
if (
- item.type !== 'folder' ||
- window.remotion_isReadOnlyStudio ||
- getCompositionDragPreviewMetadata(event.dataTransfer.types) === null
+ position === 'before' &&
+ previousSibling !== null &&
+ itemsAreEqual(activeDrag.item, itemToDescriptor(previousSibling))
) {
- return;
+ return null;
}
- event.preventDefault();
- event.stopPropagation();
- event.dataTransfer.dropEffect = 'move';
- clearRootDragHover();
+ if (
+ position === 'after' &&
+ nextSibling !== null &&
+ itemsAreEqual(activeDrag.item, itemToDescriptor(nextSibling))
+ ) {
+ return null;
+ }
+
+ if (position === 'inside' && item.type === 'folder') {
+ return canMoveIntoFolder({
+ activeDrag,
+ destinationFolderPath: getFolderPath(item),
+ })
+ ? position
+ : null;
+ }
+
+ return wouldMoveFolderIntoItself({
+ activeDrag,
+ destinationParentFolderPath: parentFolderPath,
+ })
+ ? null
+ : position;
},
- [clearRootDragHover, item],
+ [
+ activeDragRef,
+ canReorder,
+ item,
+ nextSibling,
+ parentFolderPath,
+ previousSibling,
+ ],
);
- const onFolderDrop = useCallback(
- async (event: DragEvent<HTMLElement>) => {
- if (item.type !== 'folder' || window.remotion_isReadOnlyStudio) {
+ const onRowDragOver = useCallback(
+ (event: DragEvent<HTMLElement>) => {
+ if (
+ window.remotion_isReadOnlyStudio ||
+ !hasCompositionSelectorDragData(event.dataTransfer.types)
+ ) {
return;
}
- const compositionDragData = parseCompositionDragData(event.dataTransfer);
- if (compositionDragData === null) {
+ const position = getDropPosition(event);
+ if (position === null) {
+ event.stopPropagation();
return;
}
event.preventDefault();
event.stopPropagation();
+ event.dataTransfer.dropEffect = 'move';
clearRootDragHover();
- setDragHovered(false);
-
- const isAlreadyDirectChild = item.items.some((child) => {
- return (
- child.type === 'composition' &&
- child.composition.id === compositionDragData.compositionId
- );
- });
- if (isAlreadyDirectChild) {
- return;
- }
+ setDropPosition(position);
+ },
+ [clearRootDragHover, getDropPosition],
+ );
- const notification = showNotification(
- `Moving ${compositionDragData.compositionId}...`,
- null,
- );
- const controller = new AbortController();
+ const onRowDragLeave = useCallback(() => {
+ setDropPosition(null);
+ }, []);
+ const moveItem = useCallback(
+ async ({
+ destination,
+ dragData,
+ }: {
+ destination: Extract<
+ RecastCodemod,
+ {type: 'move-composition-or-folder'}
+ >['destination'];
+ dragData: CompositionSelectorDragData;
+ }) => {
+ const label =
+ dragData.item.type === 'composition'
+ ? dragData.item.compositionId
+ : dragData.item.folderName;
+ const notification = showNotification(`Moving ${label}...`, null);
try {
const result = await applyCodemod({
codemod: {
- type: 'move-composition-to-folder',
- idToMove: compositionDragData.compositionId,
- folderName: item.folderName,
- parentName: item.parentName,
+ type: 'move-composition-or-folder',
+ source: dragData.item,
+ destination,
},
dryRun: false,
- signal: controller.signal,
+ signal: new AbortController().signal,
symbolicatedStack:
- compositionDragDataToSymbolicatedStack(compositionDragData),
+ compositionSelectorDragDataToSymbolicatedStack(dragData),
});
if (result.success) {
@@ -350,7 +545,12 @@ export const CompositionSelectorItem: React.FC<{
notification.replaceContent(result.reason, 4000);
}
- if (result.success && !item.expanded) {
+ if (
+ result.success &&
+ destination.type === 'folder' &&
+ item.type === 'folder' &&
+ !item.expanded
+ ) {
toggleFolder(item.folderName, item.parentName);
}
} catch (err) {
@@ -360,45 +560,163 @@ export const CompositionSelectorItem: React.FC<{
);
}
},
- [clearRootDragHover, item, toggleFolder],
+ [item, toggleFolder],
+ );
+
+ const onRowDrop = useCallback(
+ async (event: DragEvent<HTMLElement>) => {
+ const dragData = parseCompositionSelectorDragData(event.dataTransfer);
+ const position = getDropPosition(event);
+ if (dragData === null) {
+ return;
+ }
+
+ if (position === null) {
+ event.stopPropagation();
+ return;
+ }
+
+ event.preventDefault();
+ event.stopPropagation();
+ clearRootDragHover();
+ setDropPosition(null);
+ await moveItem({
+ dragData,
+ destination:
+ position === 'inside' && item.type === 'folder'
+ ? {
+ type: 'folder',
+ folderName: item.folderName,
+ parentName: item.parentName,
+ }
+ : {
+ type: position === 'before' ? 'before' : 'after',
+ target: itemToDescriptor(item),
+ },
+ });
+ },
+ [clearRootDragHover, getDropPosition, item, moveItem],
+ );
+
+ const onFolderChildListDragOver = useCallback(
+ (event: DragEvent<HTMLElement>) => {
+ if (
+ item.type !== 'folder' ||
+ window.remotion_isReadOnlyStudio ||
+ !hasCompositionSelectorDragData(event.dataTransfer.types)
+ ) {
+ return;
+ }
+
+ const activeDrag = activeDragRef.current;
+ if (
+ activeDrag === null ||
+ !canMoveIntoFolder({
+ activeDrag,
+ destinationFolderPath: getFolderPath(item),
+ })
+ ) {
+ event.stopPropagation();
+ return;
+ }
+
+ event.preventDefault();
+ event.stopPropagation();
+ event.dataTransfer.dropEffect = 'move';
+ clearRootDragHover();
+ },
+ [activeDragRef, clearRootDragHover, item],
+ );
+
+ const onFolderChildListDrop = useCallback(
+ async (event: DragEvent<HTMLElement>) => {
+ if (item.type !== 'folder' || window.remotion_isReadOnlyStudio) {
+ return;
+ }
+
+ const dragData = parseCompositionSelectorDragData(event.dataTransfer);
+ if (dragData === null) {
+ return;
+ }
+
+ const activeDrag = activeDragRef.current;
+ if (
+ activeDrag === null ||
+ !canMoveIntoFolder({
+ activeDrag,
+ destinationFolderPath: getFolderPath(item),
+ })
+ ) {
+ event.stopPropagation();
+ return;
+ }
+
+ event.preventDefault();
+ event.stopPropagation();
+ clearRootDragHover();
+ await moveItem({
+ dragData,
+ destination: {
+ type: 'folder',
+ folderName: item.folderName,
+ parentName: item.parentName,
+ },
+ });
+ },
+ [activeDragRef, clearRootDragHover, item, moveItem],
);
if (item.type === 'folder') {
+ const folderPath = getFolderPath(item);
return (
<>
<ContextMenu getItems={getContextMenuItems}>
- <Row align="center">
- <div
- style={style}
- className={`__remotion-composition-selector-item ${HOVERABLE_CLASS_NAME} ${HOVER_GROUP_CLASS_NAME}`}
- tabIndex={tabIndex}
- onClick={onClick}
- onKeyDown={onKeyDown}
- onDragOver={onFolderDragOver}
- onDragLeave={onFolderDragLeave}
- onDrop={onFolderDrop}
- title={item.folderName}
- role="button"
- >
- {item.expanded ? (
- <ExpandedFolderIcon style={iconStyle} color={CURRENT_COLOR} />
- ) : (
- <CollapsedFolderIcon color={CURRENT_COLOR} style={iconStyle} />
- )}
- <Spacing x={1} />
- <div style={labelStyle}>{item.folderName}</div>
- <Spacing x={0.5} />
- <CompositionContextButton
- getItems={getContextMenuItems}
- visible
- readOnlyStudio={window.remotion_isReadOnlyStudio}
- />
- </div>
- </Row>
+ <div style={reorderWrapper}>
+ {reorderLineStyle ? (
+ <div data-composition-reorder-line style={reorderLineStyle} />
+ ) : null}
+ <Row align="center">
+ <div
+ style={style}
+ className={`__remotion-composition-selector-item ${HOVERABLE_CLASS_NAME} ${HOVER_GROUP_CLASS_NAME}`}
+ tabIndex={tabIndex}
+ onClick={onClick}
+ onKeyDown={onKeyDown}
+ draggable={!window.remotion_isReadOnlyStudio}
+ onDragStart={onItemDragStart}
+ onDragEnd={onItemDragEnd}
+ onDragOver={onRowDragOver}
+ onDragLeave={onRowDragLeave}
+ onDrop={onRowDrop}
+ title={item.folderName}
+ role="button"
+ >
+ {item.expanded ? (
+ <ExpandedFolderIcon style={iconStyle} color={CURRENT_COLOR} />
+ ) : (
+ <CollapsedFolderIcon
+ color={CURRENT_COLOR}
+ style={iconStyle}
+ />
+ )}
+ <Spacing x={1} />
+ <div style={labelStyle}>{item.folderName}</div>
+ <Spacing x={0.5} />
+ <CompositionContextButton
+ getItems={getContextMenuItems}
+ visible
+ readOnlyStudio={window.remotion_isReadOnlyStudio}
+ />
+ </div>
+ </Row>
+ </div>
</ContextMenu>
{item.expanded ? (
- <div onDragOver={onFolderChildListDragOver} onDrop={onFolderDrop}>
- {item.items.map((childItem) => {
+ <div
+ onDragOver={onFolderChildListDragOver}
+ onDrop={onFolderChildListDrop}
+ >
+ {item.items.map((childItem, index) => {
return (
<CompositionSelectorItem
key={childItem.key + childItem.type}
@@ -409,6 +727,15 @@ export const CompositionSelectorItem: React.FC<{
level={level + 1}
toggleFolder={toggleFolder}
clearRootDragHover={clearRootDragHover}
+ canReorder={canReorder}
+ activeDragRef={activeDragRef}
+ parentFolderPath={folderPath}
+ previousSibling={index === 0 ? null : item.items[index - 1]}
+ nextSibling={
+ index === item.items.length - 1
+ ? null
+ : item.items[index + 1]
+ }
/>
);
})}
@@ -420,41 +747,49 @@ export const CompositionSelectorItem: React.FC<{
return (
<ContextMenu getItems={getContextMenuItems}>
- <Row align="center">
- <a
- ref={compositionRowRef}
- style={style}
- tabIndex={tabIndex}
- onClick={onClick}
- onKeyDown={onKeyDown}
- draggable={!window.remotion_isReadOnlyStudio}
- onDragStart={onCompositionDragStart}
- onDragEnd={onCompositionDragEnd}
- type="button"
- title={item.composition.id}
- className={`__remotion-composition __remotion-composition-selector-item ${HOVERABLE_CLASS_NAME} ${HOVER_GROUP_CLASS_NAME}`}
- data-compname={item.composition.id}
- >
- <CompositionOrStillIcon
- composition={item.composition}
- color={CURRENT_COLOR}
- style={iconStyle}
- />
- <Spacing x={1} />
- <div style={labelStyle}>{item.composition.id}</div>
- <Spacing x={0.5} />
- <CompositionContextButton
- getItems={getContextMenuItems}
- visible={!isDragging}
- readOnlyStudio={window.remotion_isReadOnlyStudio}
- />
- <SidebarRenderButton
- visible={!isDragging}
- composition={item.composition}
- readOnlyStudio={window.remotion_isReadOnlyStudio}
- />
- </a>
- </Row>
+ <div style={reorderWrapper}>
+ {reorderLineStyle ? (
+ <div data-composition-reorder-line style={reorderLineStyle} />
+ ) : null}
+ <Row align="center">
+ <a
+ ref={compositionRowRef}
+ style={style}
+ tabIndex={tabIndex}
+ onClick={onClick}
+ onKeyDown={onKeyDown}
+ draggable={!window.remotion_isReadOnlyStudio}
+ onDragStart={onItemDragStart}
+ onDragEnd={onItemDragEnd}
+ onDragOver={onRowDragOver}
+ onDragLeave={onRowDragLeave}
+ onDrop={onRowDrop}
+ type="button"
+ title={item.composition.id}
+ className={`__remotion-composition __remotion-composition-selector-item ${HOVERABLE_CLASS_NAME} ${HOVER_GROUP_CLASS_NAME}`}
+ data-compname={item.composition.id}
+ >
+ <CompositionOrStillIcon
+ composition={item.composition}
+ color={CURRENT_COLOR}
+ style={iconStyle}
+ />
+ <Spacing x={1} />
+ <div style={labelStyle}>{item.composition.id}</div>
+ <Spacing x={0.5} />
+ <CompositionContextButton
+ getItems={getContextMenuItems}
+ visible={!isDragging}
+ readOnlyStudio={window.remotion_isReadOnlyStudio}
+ />
+ <SidebarRenderButton
+ visible={!isDragging}
+ composition={item.composition}
+ readOnlyStudio={window.remotion_isReadOnlyStudio}
+ />
+ </a>
+ </Row>
+ </div>
</ContextMenu>
);
};
diff --git a/packages/studio/src/components/composition-selector-drag-data.ts b/packages/studio/src/components/composition-selector-drag-data.ts
new file mode 100644
index 0000000000..b2cbe4d06d
--- /dev/null
+++ b/packages/studio/src/components/composition-selector-drag-data.ts
@@ -0,0 +1,131 @@
+import type {
+ CompositionOrFolder,
+ SymbolicatedStackFrame,
+} from '@remotion/studio-shared';
+
+const MIME_TYPE = 'application/remotion-composition-selector-reorder';
+
+export type CompositionSelectorDragData = {
+ readonly type: 'remotion-composition-selector';
+ readonly version: 1;
+ readonly item: CompositionOrFolder;
+ readonly sourceFile: string | null;
+};
+
+export type CompositionSelectorActiveDrag = {
+ readonly item: CompositionOrFolder;
+ readonly parentFolderPath: string | null;
+};
+
+type DragDataTransfer = {
+ readonly types: ArrayLike<string>;
+ readonly getData: (mimeType: string) => string;
+};
+
+const isSafeString = (value: unknown, maxLength: number): value is string => {
+ return (
+ typeof value === 'string' &&
+ value.length > 0 &&
+ value.length <= maxLength &&
+ !value.includes('\0')
+ );
+};
+
+const isCompositionOrFolder = (
+ value: unknown,
+): value is CompositionOrFolder => {
+ if (typeof value !== 'object' || value === null) {
+ return false;
+ }
+
+ const item = value as Record<string, unknown>;
+ if (item.type === 'composition') {
+ return isSafeString(item.compositionId, 500);
+ }
+
+ return (
+ item.type === 'folder' &&
+ isSafeString(item.folderName, 500) &&
+ (item.parentName === null || isSafeString(item.parentName, 2000))
+ );
+};
+
+const isSafeSourceFile = (value: unknown): value is string | null => {
+ return (
+ value === null ||
+ (isSafeString(value, 2000) &&
+ !value.includes('\\') &&
+ !value.startsWith('/') &&
+ !value.split('/').includes('..'))
+ );
+};
+
+export const makeCompositionSelectorDragData = ({
+ item,
+ sourceFile,
+}: {
+ readonly item: CompositionOrFolder;
+ readonly sourceFile: string | null;
+}) => {
+ const data: CompositionSelectorDragData = {
+ type: 'remotion-composition-selector',
+ version: 1,
+ item,
+ sourceFile,
+ };
+ return {mimeType: MIME_TYPE, payload: JSON.stringify(data), data};
+};
+
+export const hasCompositionSelectorDragData = (
+ mimeTypes: ArrayLike<string>,
+) => {
+ return Array.from(mimeTypes).includes(MIME_TYPE);
+};
+
+export const parseCompositionSelectorDragData = (
+ dataTransfer: DragDataTransfer,
+): CompositionSelectorDragData | null => {
+ if (!hasCompositionSelectorDragData(dataTransfer.types)) {
+ return null;
+ }
+
+ try {
+ const parsed = JSON.parse(dataTransfer.getData(MIME_TYPE)) as Record<
+ string,
+ unknown
+ >;
+ if (
+ parsed.type !== 'remotion-composition-selector' ||
+ parsed.version !== 1 ||
+ !isCompositionOrFolder(parsed.item) ||
+ !isSafeSourceFile(parsed.sourceFile)
+ ) {
+ return null;
+ }
+
+ return {
+ type: 'remotion-composition-selector',
+ version: 1,
+ item: parsed.item,
+ sourceFile: parsed.sourceFile,
+ };
+ } catch {
+ return null;
+ }
+};
+
+export const compositionSelectorDragDataToSymbolicatedStack = (
+ dragData: CompositionSelectorDragData,
+): SymbolicatedStackFrame | null => {
+ if (dragData.sourceFile === null) {
+ return null;
+ }
+
+ return {
+ originalColumnNumber: null,
+ originalFileName: dragData.sourceFile,
+ originalFunctionName: null,
+ originalLineNumber: null,
+ originalScriptCode: null,
+ };
+};