@remotion/studio-server 4.0.537 → 4.0.539

package/dist/ansi-diff.js

@@ -5,15 +5,10 @@ const studio_shared_1 = require("@remotion/studio-shared");
 const CLEAR_LINE = Buffer.from([0x1b, 0x5b, 0x30, 0x4b]);
 const NEWLINE = Buffer.from('\n');
 class AnsiDiff {
-    x;
-    y;
-    width;
-    height;
-    _buffer;
-    _out;
-    _lines;
-    finished;
     constructor(opts) {
+        this._push = (buf) => {
+            this._out.push(buf);
+        };
         this.x = 0;
         this.y = 0;
         this.width = (opts === null || opts === void 0 ? void 0 : opts.width) || Infinity;
@@ -133,9 +128,6 @@ class AnsiDiff {
         this.x = x;
         this.y = y;
     }
-    _push = (buf) => {
-        this._out.push(buf);
-    };
 }
 exports.AnsiDiff = AnsiDiff;
 function same(a, b) {
@@ -148,14 +140,6 @@ function top(list) {
     return list.length ? list[list.length - 1] : null;
 }
 class Line {
-    y;
-    width;
-    parts;
-    height;
-    remainder;
-    raw;
-    length;
-    newline;
     constructor(str, y, nl, term) {
         this.y = y;
         this.width = term.width;

package/dist/better-opn/index.d.ts

@@ -1,6 +1,7 @@
+declare const supportedChromiumBrowsers: readonly ['Google Chrome', 'Google Chrome Canary', 'Microsoft Edge', 'Brave Browser', 'Vivaldi', 'Chromium', 'Arc'];
 export declare const getChromiumBrowsersToTry: (processes: string) => ("Arc" | "Brave Browser" | "Chromium" | "Google Chrome" | "Google Chrome Canary" | "Microsoft Edge" | "Vivaldi")[];
-export declare const getFocusBrowserTabAppleScript: (chromiumBrowser: "Arc" | "Brave Browser" | "Chromium" | "Google Chrome" | "Google Chrome Canary" | "Microsoft Edge" | "Vivaldi") => string;
-export declare const getFocusBrowserTabByOriginAppleScript: (chromiumBrowser: "Arc" | "Brave Browser" | "Chromium" | "Google Chrome" | "Google Chrome Canary" | "Microsoft Edge" | "Vivaldi") => string;
+export declare const getFocusBrowserTabAppleScript: (chromiumBrowser: (typeof supportedChromiumBrowsers)[number]) => string;
+export declare const getFocusBrowserTabByOriginAppleScript: (chromiumBrowser: (typeof supportedChromiumBrowsers)[number]) => string;
 export declare const focusBrowserTab: ({ url }: {
     url: string;
 }) => Promise<boolean>;
@@ -14,3 +15,4 @@ export declare const openBrowser: ({ url, browserFlag, browserArgs, }: {
     browserFlag: string | undefined;
     browserArgs: string | undefined;
 }) => Promise<boolean | import("child_process").ChildProcess>;
+export {};

package/dist/canvas-capture/generate-canvas-capture-composition.d.ts

@@ -0,0 +1,14 @@
+import type { CanvasCaptureData } from '@remotion/studio-shared';
+export declare const generateCanvasCaptureComposition: ({ componentName, compositionId, data, durationInFrames, fps, height, keyframeFps, videoFileName, videoHeight, videoWidth, width, }: {
+    readonly componentName: string;
+    readonly compositionId: string;
+    readonly data: CanvasCaptureData;
+    readonly durationInFrames: number;
+    readonly fps: number;
+    readonly height: number;
+    readonly keyframeFps: number;
+    readonly videoFileName: string;
+    readonly videoHeight: number;
+    readonly videoWidth: number;
+    readonly width: number;
+}) => string;

package/dist/canvas-capture/generate-canvas-capture-composition.js

@@ -0,0 +1,239 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCanvasCaptureComposition = void 0;
+const recast = __importStar(require("recast"));
+const customCursorRegex = /^\s*url\(/;
+const collapseMouseMovementsByFrame = ({ data, keyframeFps, }) => {
+    const movements = [];
+    for (const movement of data.mouseMovements) {
+        if (movement.canvasX === null || movement.canvasY === null) {
+            continue;
+        }
+        const framedMovement = {
+            ...movement,
+            frame: Math.ceil(movement.timeInSeconds * keyframeFps),
+        };
+        const previous = movements.at(-1);
+        if ((previous === null || previous === void 0 ? void 0 : previous.frame) === framedMovement.frame) {
+            movements[movements.length - 1] = framedMovement;
+        }
+        else {
+            movements.push(framedMovement);
+        }
+    }
+    return movements;
+};
+const getCursorName = (cursor) => {
+    var _a;
+    if (customCursorRegex.test(cursor)) {
+        return 'custom';
+    }
+    return ((_a = cursor.split(',').at(-1)) === null || _a === void 0 ? void 0 : _a.trim().toLowerCase()) || 'default';
+};
+const serialize = (value) => {
+    if (typeof value === 'string') {
+        return recast.prettyPrint(recast.types.builders.stringLiteral(value), {
+            quote: 'single',
+        }).code;
+    }
+    return JSON.stringify(value);
+};
+const serializeArray = (values, indentation) => {
+    const items = values.map(serialize);
+    const inline = `[${items.join(', ')}]`;
+    if (indentation * 2 + inline.length + 1 <= 80) {
+        return inline;
+    }
+    const lines = [];
+    const numeric = values.every((value) => typeof value === 'number');
+    for (const item of items) {
+        const previous = lines.at(-1);
+        if (numeric &&
+            previous &&
+            (indentation + 1) * 2 + previous.length + item.length + 2 <= 80) {
+            lines[lines.length - 1] = `${previous} ${item},`;
+        }
+        else {
+            lines.push(`${item},`);
+        }
+    }
+    return [
+        '[',
+        ...lines.map((line) => `${'\t'.repeat(indentation + 1)}${line}`),
+        `${'\t'.repeat(indentation)}]`,
+    ].join('\n');
+};
+const generateCanvasCaptureComposition = ({ componentName, compositionId, data, durationInFrames, fps, height, keyframeFps, videoFileName, videoHeight, videoWidth, width, }) => {
+    var _a;
+    const movements = collapseMouseMovementsByFrame({ data, keyframeFps });
+    if (movements.length === 0) {
+        throw new Error('The Canvas Capture does not contain cursor movements');
+    }
+    const cursorKeyframes = movements.reduce((keyframes, movement) => {
+        var _a;
+        const value = getCursorName(movement.cursor);
+        if (((_a = keyframes.at(-1)) === null || _a === void 0 ? void 0 : _a.value) !== value) {
+            keyframes.push({ frame: movement.frame, value });
+        }
+        return keyframes;
+    }, []);
+    const positionKeyframes = [];
+    for (const movement of movements) {
+        const previous = positionKeyframes.at(-1);
+        if (previous !== undefined && movement.frame - previous.frame > 1) {
+            positionKeyframes.push({
+                frame: movement.frame - 1,
+                value: previous.value,
+            });
+        }
+        positionKeyframes.push({
+            frame: movement.frame,
+            value: `${movement.canvasX}px ${movement.canvasY}px`,
+        });
+    }
+    const scaleKeyframes = [
+        { frame: 0, value: data.captureMetadata.density },
+        ...data.pointerClicks.map((click) => ({
+            frame: Math.ceil(click.timeInSeconds * keyframeFps),
+            value: click.type === 'pointer-down'
+                ? data.captureMetadata.density * 0.9
+                : data.captureMetadata.density,
+        })),
+    ].reduce((keyframes, keyframe) => {
+        var _a, _b;
+        if (((_a = keyframes.at(-1)) === null || _a === void 0 ? void 0 : _a.frame) === keyframe.frame) {
+            keyframes[keyframes.length - 1] = keyframe;
+        }
+        else if (((_b = keyframes.at(-1)) === null || _b === void 0 ? void 0 : _b.value) !== keyframe.value) {
+            keyframes.push(keyframe);
+        }
+        return keyframes;
+    }, []);
+    const customCursor = (_a = movements.find((movement) => customCursorRegex.test(movement.cursor))) === null || _a === void 0 ? void 0 : _a.cursor;
+    const cursorProp = cursorKeyframes.length === 1
+        ? `cursor={${serialize(cursorKeyframes[0].value)}}`
+        : `cursor={interpolate(
+					frame,
+					${serializeArray(cursorKeyframes.map((keyframe) => keyframe.frame), 5)},
+					${serializeArray(cursorKeyframes.map((keyframe) => keyframe.value), 5)},
+					{
+						easing: Easing.step1,
+						extrapolateLeft: 'clamp',
+						extrapolateRight: 'clamp',
+					},
+				)}`;
+    const scale = scaleKeyframes.length === 1
+        ? serialize(scaleKeyframes[0].value)
+        : `interpolate(
+						frame,
+						${serializeArray(scaleKeyframes.map((keyframe) => keyframe.frame), 6)},
+						${serializeArray(scaleKeyframes.map((keyframe) => keyframe.value), 6)},
+						{
+							easing: Easing.step1,
+							extrapolateLeft: 'clamp',
+							extrapolateRight: 'clamp',
+						},
+					)`;
+    const translate = positionKeyframes.length === 1
+        ? serialize(positionKeyframes[0].value)
+        : `interpolate(
+						frame,
+						${serializeArray(positionKeyframes.map((keyframe) => keyframe.frame), 6)},
+						${serializeArray(positionKeyframes.map((keyframe) => keyframe.value), 6)},
+						{
+							extrapolateLeft: 'clamp',
+							extrapolateRight: 'clamp',
+						},
+					)`;
+    const previewComponentName = componentName.endsWith('Composition')
+        ? `${componentName.slice(0, -'Composition'.length)}Preview`
+        : `${componentName}Preview`;
+    return `import {MacOSCursor} from '@remotion/mac-cursors';
+import {Video} from '@remotion/media';
+import {
+	AbsoluteFill,
+	Composition,
+	Easing,
+	interpolate,
+	staticFile,
+	useCurrentFrame,
+} from 'remotion';
+
+export const ${previewComponentName} = () => {
+	const frame = useCurrentFrame();
+
+	return (
+		<AbsoluteFill
+			style={{
+				width: ${videoWidth},
+				height: ${videoHeight},
+			}}
+		>
+			<Video
+				src={staticFile(${serialize(videoFileName)})}
+				style={{
+					position: 'absolute',
+				}}
+			/>
+			<MacOSCursor
+				${cursorProp}
+${customCursor === undefined ? '' : `\t\t\t\tcustomCursor={${serialize(customCursor)}}\n`}				style={{
+					position: 'absolute',
+					left: 0,
+					top: 0,
+					scale: ${scale},
+					translate: ${translate},
+				}}
+			/>
+		</AbsoluteFill>
+	);
+};
+
+export const ${componentName} = () => {
+	return (
+		<Composition
+			id={${serialize(compositionId)}}
+			component={${previewComponentName}}
+			width={${width}}
+			height={${height}}
+			fps={${fps}}
+			durationInFrames={${durationInFrames}}
+		/>
+	);
+};
+`;
+};
+exports.generateCanvasCaptureComposition = generateCanvasCaptureComposition;

package/dist/codemods/add-effect.d.ts

@@ -0,0 +1 @@
+export { addEffect, assertValidEffect, ensureEffectImport, makeConfigObjectExpression, } from '@remotion/studio-codemods';

package/dist/codemods/add-effect.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeConfigObjectExpression = exports.ensureEffectImport = exports.assertValidEffect = exports.addEffect = void 0;
+const studio_codemods_1 = require("@remotion/studio-codemods");
+Object.defineProperty(exports, "addEffect", { enumerable: true, get: function () { return studio_codemods_1.addEffect; } });
+Object.defineProperty(exports, "assertValidEffect", { enumerable: true, get: function () { return studio_codemods_1.assertValidEffect; } });
+Object.defineProperty(exports, "ensureEffectImport", { enumerable: true, get: function () { return studio_codemods_1.ensureEffectImport; } });
+Object.defineProperty(exports, "makeConfigObjectExpression", { enumerable: true, get: function () { return studio_codemods_1.makeConfigObjectExpression; } });

package/dist/codemods/apply-codemod-to-file.d.ts

@@ -0,0 +1,7 @@
+import { type CodemodResult } from '@remotion/codemods';
+import type { RecastCodemod, SymbolicatedStackFrame } from '@remotion/studio-shared';
+export declare const resolveFilePathFromSymbolicatedStack: (remotionRoot: string, stack: SymbolicatedStackFrame) => string;
+export declare const applyCodemodToFile: ({ filePath, codeMod, }: {
+    filePath: string;
+    codeMod: RecastCodemod;
+}) => Promise<CodemodResult>;

package/dist/codemods/apply-codemod-to-file.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCodemodToFile = exports.resolveFilePathFromSymbolicatedStack = void 0;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const codemods_1 = require("@remotion/codemods");
+const studio_shared_1 = require("@remotion/studio-shared");
+const resolve_file_inside_project_1 = require("../helpers/resolve-file-inside-project");
+const can_update_default_props_1 = require("../preview-server/routes/can-update-default-props");
+const resolveFilePathFromSymbolicatedStack = (remotionRoot, stack) => {
+    if (!stack.originalFileName) {
+        throw new Error('Could not determine the file where this composition is defined');
+    }
+    const { absolutePath } = (0, resolve_file_inside_project_1.resolveFileInsideProject)({
+        remotionRoot,
+        fileName: stack.originalFileName,
+        action: 'apply codemod to',
+    });
+    if (!(0, node_fs_1.existsSync)(absolutePath)) {
+        throw new Error(`File not found: ${stack.originalFileName}`);
+    }
+    return absolutePath;
+};
+exports.resolveFilePathFromSymbolicatedStack = resolveFilePathFromSymbolicatedStack;
+const applyCodemodToFile = async ({ filePath, codeMod, }) => {
+    var _a, _b, _c, _d;
+    (0, can_update_default_props_1.checkIfTypeScriptFile)(filePath);
+    const input = await (0, promises_1.readFile)(filePath, 'utf-8');
+    const options = {
+        project: { files: { [filePath]: input }, rootDir: node_path_1.default.dirname(filePath) },
+        compositionFile: filePath,
+    };
+    if (codeMod.type === 'apply-visual-control') {
+        return (0, codemods_1.updateVisualControls)({
+            ...options,
+            filePath,
+            changes: codeMod.changes,
+        });
+    }
+    if (codeMod.type === 'new-composition') {
+        const componentFilePath = node_path_1.default.join(node_path_1.default.dirname(filePath), `${codeMod.componentName}.tsx`);
+        if ((0, node_fs_1.existsSync)(componentFilePath)) {
+            throw new Error(`Cannot create ${componentFilePath} because it already exists`);
+        }
+        const composition = {
+            ...options,
+            compositionId: codeMod.newId,
+            component: {
+                filePath: componentFilePath,
+                importName: codeMod.componentName,
+                importPath: codeMod.componentImportPath,
+            },
+            metadata: {
+                width: codeMod.newWidth,
+                height: codeMod.newHeight,
+                fps: codeMod.newFps,
+                durationInFrames: codeMod.newDurationInFrames,
+            },
+            folder: codeMod.folderName === null
+                ? undefined
+                : { name: codeMod.folderName, parentName: codeMod.parentName },
+        };
+        if (codeMod.canvasCapture !== null) {
+            return (0, codemods_1.addCanvasCaptureComposition)({
+                ...composition,
+                capture: codeMod.canvasCapture,
+            });
+        }
+        const result = (0, codemods_1.addComposition)(composition);
+        return {
+            ...result,
+            changes: [
+                ...result.changes,
+                {
+                    filePath: componentFilePath,
+                    previousContents: null,
+                    nextContents: codeMod.asset === null
+                        ? (0, studio_shared_1.emptyCompositionComponent)(codeMod.componentName)
+                        : (0, studio_shared_1.assetCompositionComponent)({
+                            asset: codeMod.asset,
+                            componentName: codeMod.componentName,
+                        }),
+                },
+            ],
+        };
+    }
+    if (codeMod.type === 'rename-composition') {
+        return (0, codemods_1.renameComposition)({
+            ...options,
+            compositionId: codeMod.idToRename,
+            newId: codeMod.newId,
+        });
+    }
+    if (codeMod.type === 'delete-composition') {
+        return (0, codemods_1.deleteComposition)({ ...options, compositionId: codeMod.idToDelete });
+    }
+    if (codeMod.type === 'duplicate-composition' ||
+        codeMod.type === 'update-composition-metadata') {
+        const metadata = {
+            width: (_a = codeMod.newWidth) !== null && _a !== void 0 ? _a : undefined,
+            height: (_b = codeMod.newHeight) !== null && _b !== void 0 ? _b : undefined,
+            fps: codeMod.type === 'duplicate-composition' && codeMod.tag === 'Still'
+                ? undefined
+                : ((_c = codeMod.newFps) !== null && _c !== void 0 ? _c : undefined),
+            durationInFrames: codeMod.type === 'duplicate-composition' && codeMod.tag === 'Still'
+                ? undefined
+                : ((_d = codeMod.newDurationInFrames) !== null && _d !== void 0 ? _d : undefined),
+        };
+        const result = codeMod.type === 'duplicate-composition'
+            ? (0, codemods_1.duplicateComposition)({
+                ...options,
+                compositionId: codeMod.idToDuplicate,
+                newId: codeMod.newId,
+                tag: codeMod.tag,
+                metadata,
+            })
+            : (0, codemods_1.updateCompositionMetadata)({
+                ...options,
+                compositionId: codeMod.idToUpdate,
+                metadata,
+            });
+        return result;
+    }
+    if (codeMod.type === 'move-composition-or-folder') {
+        const target = codeMod.destination;
+        const destination = target.type === 'root'
+            ? target
+            : target.type === 'folder'
+                ? {
+                    type: 'folder',
+                    folder: { name: target.folderName, parentName: target.parentName },
+                }
+                : {
+                    type: target.type,
+                    target: target.target.type === 'composition'
+                        ? target.target
+                        : {
+                            type: 'folder',
+                            name: target.target.folderName,
+                            parentName: target.target.parentName,
+                        },
+                };
+        const result = codeMod.source.type === 'composition'
+            ? (0, codemods_1.moveComposition)({
+                ...options,
+                compositionId: codeMod.source.compositionId,
+                destination,
+            })
+            : (0, codemods_1.moveFolder)({
+                ...options,
+                folder: {
+                    name: codeMod.source.folderName,
+                    parentName: codeMod.source.parentName,
+                },
+                destination,
+            });
+        return result;
+    }
+    const folder = { name: codeMod.folderName, parentName: codeMod.parentName };
+    const folderResult = codeMod.type === 'new-folder'
+        ? (0, codemods_1.addFolder)({ ...options, folder })
+        : codeMod.type === 'rename-folder'
+            ? (0, codemods_1.renameFolder)({ ...options, folder, newName: codeMod.newName })
+            : (0, codemods_1.unwrapFolder)({ ...options, folder });
+    return folderResult;
+};
+exports.applyCodemodToFile = applyCodemodToFile;

package/dist/codemods/apply-visual-control.d.ts

@@ -0,0 +1,8 @@
+import type { File } from '@babel/types';
+import { type ApplyVisualControlCodemod } from '@remotion/studio-shared';
+import type { ApplyCodeModReturnType, Change } from './recast-mods';
+export declare const applyVisualControl: ({ file, transformation, changesMade, }: {
+    file: File;
+    transformation: ApplyVisualControlCodemod;
+    changesMade: Change[];
+}) => ApplyCodeModReturnType;

package/dist/codemods/apply-visual-control.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyVisualControl = void 0;
+const studio_shared_1 = require("@remotion/studio-shared");
+const recast = __importStar(require("recast"));
+const parse_ast_1 = require("./parse-ast");
+const expectString = (node) => {
+    if (node.type === 'StringLiteral') {
+        return node.value;
+    }
+    if (node.type === 'TemplateLiteral') {
+        if (node.expressions.length > 0) {
+            throw new Error('applyVisualControl() must use a static identifier, the string may not be dynamic.');
+        }
+        return node.quasis[0].value.raw;
+    }
+    throw new Error('Expected a string literal');
+};
+const applyVisualControl = ({ file, transformation, changesMade, }) => {
+    recast.types.visit(file.program, {
+        visitCallExpression(path) {
+            const { node } = path;
+            if (node.type !== 'CallExpression') {
+                throw new Error('Expected a call expression');
+            }
+            if (node.callee.type !== 'Identifier') {
+                return this.traverse(path);
+            }
+            if (node.callee.name !== 'visualControl') {
+                return this.traverse(path);
+            }
+            const firstArgument = node.arguments[0];
+            const str = expectString(firstArgument);
+            for (const change of transformation.changes) {
+                if (change.id !== str) {
+                    continue;
+                }
+                let parsed;
+                if (change.newValueIsUndefined) {
+                    parsed = (0, parse_ast_1.parseAst)('a = undefined').program
+                        .body[0].expression.right;
+                }
+                else {
+                    parsed = (0, parse_ast_1.parseAst)(`a = ${(0, studio_shared_1.stringifyDefaultProps)({ props: JSON.parse(change.newValueSerialized), enumPaths: change.enumPaths })}`).program.body[0].expression.right;
+                }
+                node.arguments[1] = parsed;
+                changesMade.push({
+                    description: `Applied visual control ${change.id}`,
+                });
+            }
+            return this.traverse(path);
+        },
+    });
+    return { newAst: file, changesMade };
+};
+exports.applyVisualControl = applyVisualControl;

package/dist/codemods/delete-effect.d.ts

@@ -0,0 +1 @@
+export { deleteEffect, deleteEffects, type EffectDeletionTarget, } from '@remotion/studio-codemods';

package/dist/codemods/delete-effect.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteEffects = exports.deleteEffect = void 0;
+const studio_codemods_1 = require("@remotion/studio-codemods");
+Object.defineProperty(exports, "deleteEffect", { enumerable: true, get: function () { return studio_codemods_1.deleteEffect; } });
+Object.defineProperty(exports, "deleteEffects", { enumerable: true, get: function () { return studio_codemods_1.deleteEffects; } });

package/dist/codemods/delete-jsx-node.d.ts

@@ -0,0 +1,22 @@
+import { deleteJsxElementAtPath, findJsxElementPathForDeletion, getJsxElementTagLabel } from '@remotion/studio-codemods';
+import type { SequenceNodePath } from 'remotion';
+export { deleteJsxElementAtPath, findJsxElementPathForDeletion, getJsxElementTagLabel, };
+export declare const deleteJsxNodes: ({ input, nodePaths, }: {
+    input: string;
+    nodePaths: SequenceNodePath[];
+}) => Promise<{
+    output: string;
+    formatted: boolean;
+    nodeLabels: string[];
+    logLines: number[];
+    nodePathRemappings: import("@remotion/studio-shared").SequenceNodePathRemapping[];
+}>;
+export declare const deleteJsxNode: ({ input, nodePath, }: {
+    input: string;
+    nodePath: SequenceNodePath;
+}) => Promise<{
+    output: string;
+    formatted: boolean;
+    nodeLabel: string;
+    logLine: number;
+}>;

package/dist/codemods/delete-jsx-node.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteJsxNode = exports.deleteJsxNodes = exports.getJsxElementTagLabel = exports.findJsxElementPathForDeletion = exports.deleteJsxElementAtPath = void 0;
+const studio_codemods_1 = require("@remotion/studio-codemods");
+Object.defineProperty(exports, "deleteJsxElementAtPath", { enumerable: true, get: function () { return studio_codemods_1.deleteJsxElementAtPath; } });
+Object.defineProperty(exports, "findJsxElementPathForDeletion", { enumerable: true, get: function () { return studio_codemods_1.findJsxElementPathForDeletion; } });
+Object.defineProperty(exports, "getJsxElementTagLabel", { enumerable: true, get: function () { return studio_codemods_1.getJsxElementTagLabel; } });
+const deleteJsxNodes = ({ input, nodePaths, }) => (0, studio_codemods_1.deleteJsxNodes)({
+    input,
+    nodePaths,
+});
+exports.deleteJsxNodes = deleteJsxNodes;
+const deleteJsxNode = ({ input, nodePath, }) => (0, studio_codemods_1.deleteJsxNode)({
+    input,
+    nodePath,
+});
+exports.deleteJsxNode = deleteJsxNode;

package/dist/codemods/delete-jsx-nodes.d.ts

@@ -0,0 +1,13 @@
+import type { SequenceNodePath } from 'remotion';
+declare const deleteJsxElementAtPath: (jsxPath: import("ast-types/lib/node-path").NodePath<N, V>) => void, findJsxElementPathForDeletion: (ast: import("@babel/types").File, nodePath: SequenceNodePath) => import("ast-types/lib/node-path").NodePath<N, V> | null, getJsxElementTagLabel: (element: import("@babel/types").JSXElement) => string;
+export { deleteJsxElementAtPath, findJsxElementPathForDeletion, getJsxElementTagLabel, };
+export declare const deleteJsxNodes: ({ input, nodePaths, }: {
+    input: string;
+    nodePaths: SequenceNodePath[];
+}) => Promise<{
+    output: string;
+    formatted: boolean;
+    nodeLabels: string[];
+    logLines: number[];
+    nodePathRemappings: import("@remotion/studio-shared").SequenceNodePathRemapping[];
+}>;