@remotion/studio-server 4.0.469 → 4.0.471

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

@@ -0,0 +1,15 @@
+import type { SequenceNodePath } from 'remotion';
+export declare const addEffect: ({ input, sequenceNodePath, effectName, effectImportPath, effectConfig, prettierConfigOverride, }: {
+    input: string;
+    sequenceNodePath: SequenceNodePath;
+    effectName: string;
+    effectImportPath: string;
+    effectConfig: Record<string, unknown>;
+    prettierConfigOverride?: Record<string, unknown> | null | undefined;
+}) => Promise<{
+    output: string;
+    formatted: boolean;
+    effectLabel: string;
+    nodeLabel: string;
+    logLine: number;
+}>;

package/dist/codemods/add-effect.js

@@ -0,0 +1,231 @@
+"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.addEffect = void 0;
+const studio_shared_1 = require("@remotion/studio-shared");
+const recast = __importStar(require("recast"));
+const can_update_sequence_props_1 = require("../preview-server/routes/can-update-sequence-props");
+const format_file_content_1 = require("./format-file-content");
+const parse_ast_1 = require("./parse-ast");
+const update_effect_props_1 = require("./update-effect-props/update-effect-props");
+const b = recast.types.builders;
+const identifierRegex = /^[A-Za-z_$][0-9A-Za-z_$]*$/;
+const assertValidEffect = ({ effectName, effectImportPath, }) => {
+    if (!identifierRegex.test(effectName)) {
+        throw new Error(`Invalid effect name "${effectName}"`);
+    }
+    const allowedImport = effectImportPath.startsWith('@remotion/effects/') ||
+        effectImportPath === '@remotion/light-leaks' ||
+        effectImportPath === '@remotion/starburst';
+    if (!allowedImport) {
+        throw new Error(`Unsupported effect import "${effectImportPath}"`);
+    }
+};
+const parseValueExpression = (value) => {
+    const code = `a = ${(0, studio_shared_1.stringifyDefaultProps)({ props: value, enumPaths: [] })}`;
+    const ast = (0, parse_ast_1.parseAst)(code);
+    const stmt = ast.program.body[0];
+    if (stmt.type !== 'ExpressionStatement' ||
+        stmt.expression.type !== 'AssignmentExpression') {
+        throw new Error('Failed to parse effect config value');
+    }
+    return stmt.expression.right;
+};
+const getImportedName = (specifier) => {
+    if (specifier.imported.type === 'Identifier') {
+        return specifier.imported.name;
+    }
+    return specifier.imported.value;
+};
+const declarationBindsName = (declaration, name) => {
+    var _a, _b;
+    if (declaration.type === 'ClassDeclaration') {
+        return ((_a = declaration.id) === null || _a === void 0 ? void 0 : _a.name) === name;
+    }
+    if (declaration.type === 'FunctionDeclaration') {
+        return ((_b = declaration.id) === null || _b === void 0 ? void 0 : _b.name) === name;
+    }
+    return declaration.declarations.some((variableDeclaration) => {
+        return (variableDeclaration.id.type === 'Identifier' &&
+            variableDeclaration.id.name === name);
+    });
+};
+const hasTopLevelBinding = ({ ast, name }) => {
+    return ast.program.body.some((node) => {
+        var _a;
+        if (node.type === 'FunctionDeclaration' ||
+            node.type === 'ClassDeclaration' ||
+            node.type === 'VariableDeclaration') {
+            return declarationBindsName(node, name);
+        }
+        if (node.type === 'ExportNamedDeclaration' &&
+            node.declaration &&
+            (node.declaration.type === 'FunctionDeclaration' ||
+                node.declaration.type === 'ClassDeclaration' ||
+                node.declaration.type === 'VariableDeclaration')) {
+            return declarationBindsName(node.declaration, name);
+        }
+        if (node.type !== 'ImportDeclaration') {
+            return false;
+        }
+        return (_a = node.specifiers) === null || _a === void 0 ? void 0 : _a.some((specifier) => {
+            var _a;
+            return ((_a = specifier.local) === null || _a === void 0 ? void 0 : _a.name) === name;
+        });
+    });
+};
+const insertImportDeclaration = (ast, importDeclaration) => {
+    const { body } = ast.program;
+    let lastImportIndex = -1;
+    for (let i = 0; i < body.length; i++) {
+        if (body[i].type === 'ImportDeclaration') {
+            lastImportIndex = i;
+        }
+    }
+    body.splice(lastImportIndex + 1, 0, importDeclaration);
+};
+const getAvailableLocalName = ({ ast, effectName, }) => {
+    if (!hasTopLevelBinding({ ast, name: effectName })) {
+        return effectName;
+    }
+    const base = `${effectName}Effect`;
+    if (!hasTopLevelBinding({ ast, name: base })) {
+        return base;
+    }
+    for (let i = 2; i < 100; i++) {
+        const candidate = `${base}${i}`;
+        if (!hasTopLevelBinding({ ast, name: candidate })) {
+            return candidate;
+        }
+    }
+    throw new Error(`Cannot find a local name for ${effectName}`);
+};
+const ensureEffectImport = ({ ast, effectName, effectImportPath, }) => {
+    var _a, _b, _c;
+    var _d;
+    let importDeclaration = null;
+    for (const node of ast.program.body) {
+        if (node.type !== 'ImportDeclaration' ||
+            node.source.value !== effectImportPath) {
+            continue;
+        }
+        importDeclaration = node;
+        const matchingSpecifier = (_a = node.specifiers) === null || _a === void 0 ? void 0 : _a.find((importSpecifier) => {
+            return (importSpecifier.type === 'ImportSpecifier' &&
+                getImportedName(importSpecifier) === effectName);
+        });
+        if ((_b = matchingSpecifier === null || matchingSpecifier === void 0 ? void 0 : matchingSpecifier.local) === null || _b === void 0 ? void 0 : _b.name) {
+            return matchingSpecifier.local.name;
+        }
+    }
+    const localName = getAvailableLocalName({ ast, effectName });
+    const imported = b.identifier(effectName);
+    const local = localName === effectName ? null : b.identifier(localName);
+    const specifier = b.importSpecifier(imported, local);
+    if (importDeclaration &&
+        !((_c = importDeclaration.specifiers) === null || _c === void 0 ? void 0 : _c.some((importSpecifier) => importSpecifier.type === 'ImportNamespaceSpecifier'))) {
+        importDeclaration.specifiers = [
+            ...((_d = importDeclaration.specifiers) !== null && _d !== void 0 ? _d : []),
+            specifier,
+        ];
+        return localName;
+    }
+    const newImport = b.importDeclaration([], b.stringLiteral(effectImportPath));
+    newImport.specifiers = [specifier];
+    insertImportDeclaration(ast, newImport);
+    return localName;
+};
+const getEffectsArray = (attr) => {
+    if (!attr.value || attr.value.type !== 'JSXExpressionContainer') {
+        throw new Error('Cannot add effect: effects prop is not an array');
+    }
+    const expr = attr.value.expression;
+    if (expr.type !== 'ArrayExpression') {
+        throw new Error('Cannot add effect: effects prop is not an array');
+    }
+    return expr;
+};
+const makeEffectsAttr = (array) => {
+    return b.jsxAttribute(b.jsxIdentifier('effects'), b.jsxExpressionContainer(array));
+};
+const makeConfigObjectExpression = (config) => {
+    return b.objectExpression(Object.entries(config).map(([key, value]) => {
+        const keyNode = identifierRegex.test(key)
+            ? b.identifier(key)
+            : b.stringLiteral(key);
+        return b.objectProperty(keyNode, parseValueExpression(value));
+    }));
+};
+const getJsxTagLabel = (name) => {
+    if (name.type === 'JSXIdentifier') {
+        return `<${name.name}>`;
+    }
+    return 'element';
+};
+const addEffect = async ({ input, sequenceNodePath, effectName, effectImportPath, effectConfig, prettierConfigOverride, }) => {
+    var _a;
+    var _b, _c;
+    assertValidEffect({ effectName, effectImportPath });
+    const ast = (0, parse_ast_1.parseAst)(input);
+    const jsx = (0, can_update_sequence_props_1.findJsxElementAtNodePath)(ast, sequenceNodePath);
+    if (!jsx) {
+        throw new Error('Could not find a JSX element at the specified location to add effect');
+    }
+    const localName = ensureEffectImport({ ast, effectName, effectImportPath });
+    const effectCall = b.callExpression(b.identifier(localName), [
+        makeConfigObjectExpression(effectConfig),
+    ]);
+    const attr = (0, update_effect_props_1.findEffectsAttr)((_b = jsx.attributes) !== null && _b !== void 0 ? _b : []);
+    if (attr) {
+        getEffectsArray(attr).elements.push(effectCall);
+    }
+    else {
+        const effectsArray = b.arrayExpression([effectCall]);
+        jsx.attributes.push(makeEffectsAttr(effectsArray));
+    }
+    const finalFile = (0, parse_ast_1.serializeAst)(ast);
+    const { output, formatted } = await (0, format_file_content_1.formatFileContent)({
+        input: finalFile,
+        prettierConfigOverride,
+    });
+    return {
+        output,
+        formatted,
+        effectLabel: `${effectName}()`,
+        nodeLabel: getJsxTagLabel(jsx.name),
+        logLine: (_c = (_a = jsx.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _c !== void 0 ? _c : 1,
+    };
+};
+exports.addEffect = addEffect;

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

@@ -1,4 +1,22 @@
 import type { SequenceNodePath } from 'remotion';
+export type EffectDeletionTarget = {
+    sequenceNodePath: SequenceNodePath;
+} & ({
+    type: 'single-effect';
+    effectIndex: number;
+} | {
+    type: 'all-effects';
+});
+export declare const deleteEffects: ({ input, effects, prettierConfigOverride, }: {
+    input: string;
+    effects: EffectDeletionTarget[];
+    prettierConfigOverride?: Record<string, unknown> | null | undefined;
+}) => Promise<{
+    output: string;
+    formatted: boolean;
+    effectLabels: string[];
+    logLines: number[];
+}>;
 export declare const deleteEffect: ({ input, sequenceNodePath, effectIndex, prettierConfigOverride, }: {
     input: string;
     sequenceNodePath: SequenceNodePath;

package/dist/codemods/delete-effect.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteEffect = void 0;
+exports.deleteEffect = exports.deleteEffects = void 0;
 const can_update_sequence_props_1 = require("../preview-server/routes/can-update-sequence-props");
 const format_file_content_1 = require("./format-file-content");
 const parse_ast_1 = require("./parse-ast");
@@ -15,28 +15,88 @@ const getEffectsArray = (attr) => {
     }
     return expr;
 };
-const deleteEffect = async ({ input, sequenceNodePath, effectIndex, prettierConfigOverride, }) => {
+const getAllEffectLabels = (effectsArray, attr) => {
+    if (effectsArray.elements.length === 0) {
+        throw new Error('Cannot delete effect: no effects found');
+    }
+    const elements = (0, update_effect_props_1.enumerateEffectArrayElements)(effectsArray);
+    return {
+        effectLabels: elements.map((effect) => effect.kind === 'call' ? `${effect.callee}()` : 'effect'),
+        logLines: elements.map((effect) => {
+            var _a, _b, _c;
+            var _d, _e, _f;
+            return effect.kind === 'call'
+                ? ((_e = (_d = (_a = effect.node.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _d !== void 0 ? _d : (_b = attr.loc) === null || _b === void 0 ? void 0 : _b.start.line) !== null && _e !== void 0 ? _e : 1)
+                : ((_f = (_c = attr.loc) === null || _c === void 0 ? void 0 : _c.start.line) !== null && _f !== void 0 ? _f : 1);
+        }),
+    };
+};
+const deleteEffects = async ({ input, effects, prettierConfigOverride, }) => {
     var _a, _b;
     var _c, _d, _e;
-    const ast = (0, parse_ast_1.parseAst)(input);
-    const jsx = (0, can_update_sequence_props_1.findJsxElementAtNodePath)(ast, sequenceNodePath);
-    if (!jsx) {
-        throw new Error('Could not find a JSX element at the specified location to delete effect');
+    if (effects.length === 0) {
+        throw new Error('No effects were specified for deletion');
     }
-    const attr = (0, update_effect_props_1.findEffectsAttr)((_c = jsx.attributes) !== null && _c !== void 0 ? _c : []);
-    if (!attr) {
-        throw new Error('Could not find effects on the target JSX element');
-    }
-    const effectsArray = getEffectsArray(attr);
-    const found = (0, update_effect_props_1.findEffectCallExpression)({ attr, effectIndex });
-    if (found.kind === 'error') {
-        throw new Error(`Cannot delete effect: ${found.reason}`);
+    const ast = (0, parse_ast_1.parseAst)(input);
+    const deletionsByAttr = new Map();
+    for (const effect of effects) {
+        const { sequenceNodePath } = effect;
+        const jsx = (0, can_update_sequence_props_1.findJsxElementAtNodePath)(ast, sequenceNodePath);
+        if (!jsx) {
+            throw new Error('Could not find a JSX element at the specified location to delete effect');
+        }
+        const attr = (0, update_effect_props_1.findEffectsAttr)((_c = jsx.attributes) !== null && _c !== void 0 ? _c : []);
+        if (!attr) {
+            throw new Error('Could not find effects on the target JSX element');
+        }
+        const effectsArray = getEffectsArray(attr);
+        const existingDeletion = deletionsByAttr.get(attr);
+        const deletion = existingDeletion !== null && existingDeletion !== void 0 ? existingDeletion : {
+            jsxAttributes: jsx.attributes,
+            attr,
+            effectsArray,
+            allEffects: false,
+            effectIndices: new Set(),
+            effectLabels: [],
+            logLines: [],
+        };
+        deletionsByAttr.set(attr, deletion);
+        if (effect.type === 'all-effects') {
+            const { effectLabels, logLines } = getAllEffectLabels(effectsArray, attr);
+            deletion.allEffects = true;
+            deletion.effectIndices.clear();
+            deletion.effectLabels = effectLabels;
+            deletion.logLines = logLines;
+            continue;
+        }
+        const { effectIndex } = effect;
+        if (deletion.allEffects || deletion.effectIndices.has(effectIndex)) {
+            continue;
+        }
+        const found = (0, update_effect_props_1.findEffectCallExpression)({ attr, effectIndex });
+        if (found.kind === 'error') {
+            throw new Error(`Cannot delete effect: ${found.reason}`);
+        }
+        deletion.effectIndices.add(effectIndex);
+        deletion.effectLabels.push(`${found.callee}()`);
+        deletion.logLines.push((_e = (_d = (_a = found.call.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _d !== void 0 ? _d : (_b = jsx.loc) === null || _b === void 0 ? void 0 : _b.start.line) !== null && _e !== void 0 ? _e : 1);
     }
-    effectsArray.elements.splice(effectIndex, 1);
-    if (effectsArray.elements.length === 0) {
-        const attrIndex = jsx.attributes.indexOf(attr);
-        if (attrIndex !== -1) {
-            jsx.attributes.splice(attrIndex, 1);
+    for (const deletion of deletionsByAttr.values()) {
+        if (deletion.allEffects) {
+            const attrIndex = deletion.jsxAttributes.indexOf(deletion.attr);
+            if (attrIndex !== -1) {
+                deletion.jsxAttributes.splice(attrIndex, 1);
+            }
+            continue;
+        }
+        for (const effectIndex of [...deletion.effectIndices].sort((a, b) => b - a)) {
+            deletion.effectsArray.elements.splice(effectIndex, 1);
+        }
+        if (deletion.effectsArray.elements.length === 0) {
+            const attrIndex = deletion.jsxAttributes.indexOf(deletion.attr);
+            if (attrIndex !== -1) {
+                deletion.jsxAttributes.splice(attrIndex, 1);
+            }
         }
     }
     const finalFile = (0, parse_ast_1.serializeAst)(ast);
@@ -47,8 +107,22 @@ const deleteEffect = async ({ input, sequenceNodePath, effectIndex, prettierConf
     return {
         output,
         formatted,
-        effectLabel: `${found.callee}()`,
-        logLine: (_e = (_d = (_a = found.call.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _d !== void 0 ? _d : (_b = jsx.loc) === null || _b === void 0 ? void 0 : _b.start.line) !== null && _e !== void 0 ? _e : 1,
+        effectLabels: [...deletionsByAttr.values()].flatMap((deletion) => deletion.effectLabels),
+        logLines: [...deletionsByAttr.values()].flatMap((deletion) => deletion.logLines),
+    };
+};
+exports.deleteEffects = deleteEffects;
+const deleteEffect = async ({ input, sequenceNodePath, effectIndex, prettierConfigOverride, }) => {
+    const { output, formatted, effectLabels, logLines } = await (0, exports.deleteEffects)({
+        input,
+        effects: [{ type: 'single-effect', sequenceNodePath, effectIndex }],
+        prettierConfigOverride,
+    });
+    return {
+        output,
+        formatted,
+        effectLabel: effectLabels[0],
+        logLine: logLines[0],
     };
 };
 exports.deleteEffect = deleteEffect;

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

@@ -4,6 +4,16 @@ import type { SequenceNodePath } from 'remotion';
 export declare const getJsxElementTagLabel: (element: JSXElement) => string;
 export declare const findJsxElementPathForDeletion: (ast: File, nodePath: SequenceNodePath) => import("ast-types/lib/node-path").NodePath<N, V> | null;
 export declare const deleteJsxElementAtPath: (jsxPath: import("ast-types/lib/node-path").NodePath<N, V>) => void;
+export declare const deleteJsxNodes: ({ input, nodePaths, prettierConfigOverride, }: {
+    input: string;
+    nodePaths: SequenceNodePath[];
+    prettierConfigOverride?: Record<string, unknown> | null | undefined;
+}) => Promise<{
+    output: string;
+    formatted: boolean;
+    nodeLabels: string[];
+    logLines: number[];
+}>;
 export declare const deleteJsxNode: ({ input, nodePath, prettierConfigOverride, }: {
     input: string;
     nodePath: SequenceNodePath;

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

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteJsxNode = exports.deleteJsxElementAtPath = exports.findJsxElementPathForDeletion = exports.getJsxElementTagLabel = void 0;
+exports.deleteJsxNode = exports.deleteJsxNodes = exports.deleteJsxElementAtPath = exports.findJsxElementPathForDeletion = exports.getJsxElementTagLabel = void 0;
 const recast = __importStar(require("recast"));
 const get_ast_node_path_1 = require("../helpers/get-ast-node-path");
 const format_file_content_1 = require("./format-file-content");
@@ -287,18 +287,28 @@ const deleteJsxElementAtPath = (jsxPath) => {
     jsxPath.replace(b.nullLiteral());
 };
 exports.deleteJsxElementAtPath = deleteJsxElementAtPath;
-const deleteJsxNode = async ({ input, nodePath, prettierConfigOverride, }) => {
-    var _a, _b;
-    var _c, _d;
+const deleteJsxNodes = async ({ input, nodePaths, prettierConfigOverride, }) => {
+    if (nodePaths.length === 0) {
+        throw new Error('No JSX nodes were specified for deletion');
+    }
     const ast = (0, parse_ast_1.parseAst)(input);
-    const jsxPath = (0, exports.findJsxElementPathForDeletion)(ast, nodePath);
-    if (!jsxPath) {
-        throw new Error('Could not find a JSX element at the specified location to delete');
-    }
-    const jsxElement = jsxPath.node;
-    const nodeLabel = (0, exports.getJsxElementTagLabel)(jsxElement);
-    const logLine = (_d = (_c = (_a = jsxElement.openingElement.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _c !== void 0 ? _c : (_b = jsxElement.loc) === null || _b === void 0 ? void 0 : _b.start.line) !== null && _d !== void 0 ? _d : 1;
-    (0, exports.deleteJsxElementAtPath)(jsxPath);
+    const pathsToDelete = nodePaths.map((nodePath) => {
+        var _a, _b;
+        var _c, _d;
+        const jsxPath = (0, exports.findJsxElementPathForDeletion)(ast, nodePath);
+        if (!jsxPath) {
+            throw new Error('Could not find a JSX element at the specified location to delete');
+        }
+        const jsxElement = jsxPath.node;
+        return {
+            jsxPath,
+            nodeLabel: (0, exports.getJsxElementTagLabel)(jsxElement),
+            logLine: (_d = (_c = (_a = jsxElement.openingElement.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _c !== void 0 ? _c : (_b = jsxElement.loc) === null || _b === void 0 ? void 0 : _b.start.line) !== null && _d !== void 0 ? _d : 1,
+        };
+    });
+    for (const { jsxPath } of pathsToDelete) {
+        (0, exports.deleteJsxElementAtPath)(jsxPath);
+    }
     const finalFile = (0, parse_ast_1.serializeAst)(ast);
     const { output, formatted } = await (0, format_file_content_1.formatFileContent)({
         input: finalFile,
@@ -307,8 +317,22 @@ const deleteJsxNode = async ({ input, nodePath, prettierConfigOverride, }) => {
     return {
         output,
         formatted,
-        nodeLabel,
-        logLine,
+        nodeLabels: pathsToDelete.map(({ nodeLabel }) => nodeLabel),
+        logLines: pathsToDelete.map(({ logLine }) => logLine),
+    };
+};
+exports.deleteJsxNodes = deleteJsxNodes;
+const deleteJsxNode = async ({ input, nodePath, prettierConfigOverride, }) => {
+    const { output, formatted, nodeLabels, logLines } = await (0, exports.deleteJsxNodes)({
+        input,
+        nodePaths: [nodePath],
+        prettierConfigOverride,
+    });
+    return {
+        output,
+        formatted,
+        nodeLabel: nodeLabels[0],
+        logLine: logLines[0],
     };
 };
 exports.deleteJsxNode = deleteJsxNode;

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

@@ -0,0 +1,13 @@
+import type { SequenceNodePath } from 'remotion';
+export declare const reorderEffect: ({ input, sequenceNodePath, fromIndex, toIndex, prettierConfigOverride, }: {
+    input: string;
+    sequenceNodePath: SequenceNodePath;
+    fromIndex: number;
+    toIndex: number;
+    prettierConfigOverride?: Record<string, unknown> | null | undefined;
+}) => Promise<{
+    output: string;
+    formatted: boolean;
+    effectLabel: string;
+    logLine: number;
+}>;

package/dist/codemods/reorder-effect.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reorderEffect = void 0;
+const can_update_sequence_props_1 = require("../preview-server/routes/can-update-sequence-props");
+const format_file_content_1 = require("./format-file-content");
+const parse_ast_1 = require("./parse-ast");
+const update_effect_props_1 = require("./update-effect-props/update-effect-props");
+const getEffectsArray = (attr) => {
+    if (!attr.value || attr.value.type !== 'JSXExpressionContainer') {
+        throw new Error('Cannot reorder effect: effects prop is not an array');
+    }
+    const expr = attr.value.expression;
+    if (expr.type !== 'ArrayExpression') {
+        throw new Error('Cannot reorder effect: effects prop is not an array');
+    }
+    return expr;
+};
+const reorderEffect = async ({ input, sequenceNodePath, fromIndex, toIndex, prettierConfigOverride, }) => {
+    var _a, _b;
+    var _c, _d, _e;
+    const ast = (0, parse_ast_1.parseAst)(input);
+    const jsx = (0, can_update_sequence_props_1.findJsxElementAtNodePath)(ast, sequenceNodePath);
+    if (!jsx) {
+        throw new Error('Could not find a JSX element at the specified location to reorder effect');
+    }
+    const attr = (0, update_effect_props_1.findEffectsAttr)((_c = jsx.attributes) !== null && _c !== void 0 ? _c : []);
+    if (!attr) {
+        throw new Error('Could not find effects on the target JSX element');
+    }
+    const effectsArray = getEffectsArray(attr);
+    const elements = (0, update_effect_props_1.enumerateEffectArrayElements)(effectsArray);
+    if (fromIndex < 0 || fromIndex >= elements.length) {
+        throw new Error('Cannot reorder effect: source index not-found');
+    }
+    if (toIndex < 0 || toIndex >= elements.length) {
+        throw new Error('Cannot reorder effect: target index not-found');
+    }
+    const target = elements[fromIndex];
+    if (target.kind !== 'call') {
+        throw new Error('Cannot reorder effect: source effect is not-call-expression');
+    }
+    if (fromIndex !== toIndex) {
+        const [moved] = effectsArray.elements.splice(fromIndex, 1);
+        if (!moved) {
+            throw new Error('Cannot reorder effect: source effect is not-call-expression');
+        }
+        effectsArray.elements.splice(toIndex, 0, moved);
+    }
+    const finalFile = (0, parse_ast_1.serializeAst)(ast);
+    const { output, formatted } = await (0, format_file_content_1.formatFileContent)({
+        input: finalFile,
+        prettierConfigOverride,
+    });
+    return {
+        output,
+        formatted,
+        effectLabel: `${target.callee}()`,
+        logLine: (_e = (_d = (_a = target.node.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _d !== void 0 ? _d : (_b = jsx.loc) === null || _b === void 0 ? void 0 : _b.start.line) !== null && _e !== void 0 ? _e : 1,
+    };
+};
+exports.reorderEffect = reorderEffect;

package/dist/codemods/update-keyframes/ensure-imports-and-frame-hook.d.ts

@@ -0,0 +1,4 @@
+import type { File } from '@babel/types';
+export declare const findEnclosingFunctionPath: (path: import("ast-types/lib/node-path").NodePath<N, V>) => import("ast-types/lib/node-path").NodePath<N, V> | null;
+export declare const ensureRemotionImports: (ast: File, names: ReadonlySet<string>) => void;
+export declare const ensureUseCurrentFrameHook: (functionPath: import("ast-types/lib/node-path").NodePath<N, V>) => void;