@remotion/studio-server 4.0.471 → 4.0.473

package/dist/helpers/import-agnostic-node-path.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromImportAgnosticNodePath = exports.toImportAgnosticNodePath = void 0;
+const getActualIndex = ({ items, agnosticIndex, shouldIgnore, context, }) => {
+    let seenIncludedNodes = 0;
+    for (let i = 0; i < items.length; i++) {
+        if (shouldIgnore(items[i], context)) {
+            continue;
+        }
+        if (seenIncludedNodes === agnosticIndex) {
+            return i;
+        }
+        seenIncludedNodes++;
+    }
+    return null;
+};
+const getAgnosticIndex = ({ items, actualIndex, shouldIgnore, context, }) => {
+    if (actualIndex < 0 || actualIndex >= items.length) {
+        return null;
+    }
+    let seenIncludedNodes = 0;
+    for (let i = 0; i <= actualIndex; i++) {
+        if (shouldIgnore(items[i], context)) {
+            continue;
+        }
+        if (i === actualIndex) {
+            return seenIncludedNodes;
+        }
+        seenIncludedNodes++;
+    }
+    return null;
+};
+const getUseCurrentFrameLocalNames = (ast) => {
+    var _a;
+    var _b;
+    const names = new Set(['useCurrentFrame']);
+    for (const statement of ast.program.body) {
+        if (statement.type !== 'ImportDeclaration' ||
+            statement.source.value !== 'remotion') {
+            continue;
+        }
+        for (const specifier of statement.specifiers) {
+            if (specifier.type === 'ImportSpecifier' &&
+                specifier.imported.type === 'Identifier' &&
+                specifier.imported.name === 'useCurrentFrame') {
+                names.add((_b = (_a = specifier.local) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : 'useCurrentFrame');
+            }
+        }
+    }
+    return names;
+};
+const isUseCurrentFrameCall = (node, useCurrentFrameLocalNames) => {
+    return ((node === null || node === void 0 ? void 0 : node.type) === 'CallExpression' &&
+        node.callee.type === 'Identifier' &&
+        useCurrentFrameLocalNames.has(node.callee.name));
+};
+const isUseCurrentFrameStatement = (node, useCurrentFrameLocalNames) => {
+    if (node.type === 'ExpressionStatement') {
+        return isUseCurrentFrameCall(node.expression, useCurrentFrameLocalNames);
+    }
+    if (node.type !== 'VariableDeclaration' || node.declarations.length !== 1) {
+        return false;
+    }
+    return isUseCurrentFrameCall(node.declarations[0].init, useCurrentFrameLocalNames);
+};
+const getIgnoredNodePredicate = (ast) => {
+    const useCurrentFrameLocalNames = getUseCurrentFrameLocalNames(ast);
+    return (node, { parent, property }) => {
+        if (parent.type === 'Program' &&
+            property === 'body' &&
+            node.type === 'ImportDeclaration') {
+            return true;
+        }
+        if (parent.type === 'BlockStatement' && property === 'body') {
+            return isUseCurrentFrameStatement(node, useCurrentFrameLocalNames);
+        }
+        return false;
+    };
+};
+const getChild = (value, segment) => {
+    var _a, _b;
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        return (_a = value[segment]) !== null && _a !== void 0 ? _a : null;
+    }
+    if (typeof value !== 'object') {
+        return null;
+    }
+    return (_b = value[segment]) !== null && _b !== void 0 ? _b : null;
+};
+const transformNodePathIndices = ({ ast, nodePath, direction, }) => {
+    const shouldIgnore = getIgnoredNodePredicate(ast);
+    const transformed = [];
+    let current = ast;
+    let arrayContext = null;
+    for (const segment of nodePath) {
+        if (typeof segment === 'string') {
+            const parent = current;
+            current = getChild(current, segment);
+            if (Array.isArray(current) &&
+                parent &&
+                typeof parent === 'object' &&
+                'type' in parent) {
+                arrayContext = { parent: parent, property: segment };
+            }
+            else {
+                arrayContext = null;
+            }
+            transformed.push(segment);
+            continue;
+        }
+        if (!Array.isArray(current) || !arrayContext) {
+            current = getChild(current, segment);
+            transformed.push(segment);
+            continue;
+        }
+        const mappedIndex = direction === 'to-agnostic'
+            ? getAgnosticIndex({
+                items: current,
+                actualIndex: segment,
+                shouldIgnore,
+                context: arrayContext,
+            })
+            : getActualIndex({
+                items: current,
+                agnosticIndex: segment,
+                shouldIgnore,
+                context: arrayContext,
+            });
+        if (mappedIndex === null) {
+            if (direction === 'from-agnostic') {
+                return null;
+            }
+            current = getChild(current, segment);
+            transformed.push(segment);
+            continue;
+        }
+        current = getChild(current, direction === 'to-agnostic' ? segment : mappedIndex);
+        arrayContext = null;
+        transformed.push(mappedIndex);
+    }
+    return transformed;
+};
+const toImportAgnosticNodePath = ({ ast, nodePath, }) => {
+    var _a;
+    return ((_a = transformNodePathIndices({ ast, nodePath, direction: 'to-agnostic' })) !== null && _a !== void 0 ? _a : nodePath);
+};
+exports.toImportAgnosticNodePath = toImportAgnosticNodePath;
+const fromImportAgnosticNodePath = ({ ast, nodePath, }) => {
+    return transformNodePathIndices({ ast, nodePath, direction: 'from-agnostic' });
+};
+exports.fromImportAgnosticNodePath = fromImportAgnosticNodePath;

package/dist/helpers/imports.d.ts

@@ -0,0 +1,16 @@
+import type { File, ImportDeclaration, ImportSpecifier } from '@babel/types';
+export declare const getImportedName: (specifier: ImportSpecifier) => string;
+export declare const findImportDeclaration: (ast: File, sourcePath: string) => ImportDeclaration | null;
+export declare const insertImportDeclaration: (ast: File, importDeclaration: ImportDeclaration) => void;
+export declare const normalizeImportSpacing: (input: string) => string;
+export declare const ensureNamedImport: ({ ast, importedName, sourcePath, localName, }: {
+    ast: File;
+    importedName: string;
+    sourcePath: string;
+    localName: string;
+}) => string;
+export declare const ensureNamedImports: ({ ast, importedNames, sourcePath, }: {
+    ast: File;
+    importedNames: ReadonlySet<string>;
+    sourcePath: string;
+}) => void;

package/dist/helpers/imports.js

@@ -0,0 +1,145 @@
+"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.ensureNamedImports = exports.ensureNamedImport = exports.normalizeImportSpacing = exports.insertImportDeclaration = exports.findImportDeclaration = exports.getImportedName = void 0;
+const recast = __importStar(require("recast"));
+const b = recast.types.builders;
+const getImportedName = (specifier) => {
+    if (specifier.imported.type === 'Identifier') {
+        return specifier.imported.name;
+    }
+    return specifier.imported.value;
+};
+exports.getImportedName = getImportedName;
+const findImportDeclaration = (ast, sourcePath) => {
+    for (const stmt of ast.program.body) {
+        if (stmt.type === 'ImportDeclaration' &&
+            stmt.source.type === 'StringLiteral' &&
+            stmt.source.value === sourcePath) {
+            return stmt;
+        }
+    }
+    return null;
+};
+exports.findImportDeclaration = findImportDeclaration;
+const findImportDeclarations = (ast, sourcePath) => {
+    return ast.program.body.filter((stmt) => stmt.type === 'ImportDeclaration' &&
+        stmt.source.type === 'StringLiteral' &&
+        stmt.source.value === sourcePath);
+};
+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);
+};
+exports.insertImportDeclaration = insertImportDeclaration;
+const normalizeImportSpacing = (input) => {
+    return input.replace(/(import[^\n]*\n)\n+(?=import\b)/g, '$1');
+};
+exports.normalizeImportSpacing = normalizeImportSpacing;
+const hasNamespaceSpecifier = (importDeclaration) => {
+    var _a;
+    return (_a = importDeclaration.specifiers) === null || _a === void 0 ? void 0 : _a.some((specifier) => specifier.type === 'ImportNamespaceSpecifier');
+};
+const ensureNamedImport = ({ ast, importedName, sourcePath, localName, }) => {
+    var _a, _b;
+    var _c, _d;
+    const existingImports = findImportDeclarations(ast, sourcePath);
+    for (const existingImportDeclaration of existingImports) {
+        const matchingSpecifier = (_a = existingImportDeclaration.specifiers) === null || _a === void 0 ? void 0 : _a.find((importSpecifierCandidate) => importSpecifierCandidate.type === 'ImportSpecifier' &&
+            (0, exports.getImportedName)(importSpecifierCandidate) === importedName);
+        if (matchingSpecifier) {
+            return (_c = (_b = matchingSpecifier.local) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : importedName;
+        }
+    }
+    const existingImport = existingImports.find((candidateImportDeclaration) => !hasNamespaceSpecifier(candidateImportDeclaration));
+    if (existingImport) {
+        const importSpecifier = b.importSpecifier(b.identifier(importedName), localName === importedName ? null : b.identifier(localName));
+        existingImport.specifiers = [
+            ...((_d = existingImport.specifiers) !== null && _d !== void 0 ? _d : []),
+            importSpecifier,
+        ];
+        return localName;
+    }
+    const specifier = b.importSpecifier(b.identifier(importedName), localName === importedName ? null : b.identifier(localName));
+    const importDeclaration = b.importDeclaration([specifier], b.stringLiteral(sourcePath));
+    (0, exports.insertImportDeclaration)(ast, importDeclaration);
+    return localName;
+};
+exports.ensureNamedImport = ensureNamedImport;
+const ensureNamedImports = ({ ast, importedNames, sourcePath, }) => {
+    var _a, _b;
+    if (importedNames.size === 0) {
+        return;
+    }
+    const existingImports = findImportDeclarations(ast, sourcePath);
+    const existingNames = new Set();
+    for (const existingImportDeclaration of existingImports) {
+        for (const importSpecifierCandidate of (_a = existingImportDeclaration.specifiers) !== null && _a !== void 0 ? _a : []) {
+            if (importSpecifierCandidate.type !== 'ImportSpecifier') {
+                continue;
+            }
+            existingNames.add((0, exports.getImportedName)(importSpecifierCandidate));
+        }
+    }
+    const existingImport = existingImports.find((candidateImportDeclaration) => !hasNamespaceSpecifier(candidateImportDeclaration));
+    if (existingImport) {
+        for (const importedName of importedNames) {
+            if (existingNames.has(importedName)) {
+                continue;
+            }
+            existingImport.specifiers = [
+                ...((_b = existingImport.specifiers) !== null && _b !== void 0 ? _b : []),
+                b.importSpecifier(b.identifier(importedName)),
+            ];
+            existingNames.add(importedName);
+        }
+        return;
+    }
+    const specifiers = [...importedNames]
+        .filter((importedName) => !existingNames.has(importedName))
+        .map((importedName) => b.importSpecifier(b.identifier(importedName)));
+    if (specifiers.length === 0) {
+        return;
+    }
+    const importDeclaration = b.importDeclaration(specifiers, b.stringLiteral(sourcePath));
+    (0, exports.insertImportDeclaration)(ast, importDeclaration);
+};
+exports.ensureNamedImports = ensureNamedImports;

package/dist/helpers/resolve-composition-component.js

@@ -42,6 +42,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const recast = __importStar(require("recast"));
 const format_file_content_1 = require("../codemods/format-file-content");
 const parse_ast_1 = require("../codemods/parse-ast");
+const imports_1 = require("./imports");
 const allowedFileExtensions = new Set(['.tsx', '.ts', '.jsx', '.js']);
 const extensionsToProbe = ['.tsx', '.ts', '.jsx', '.js'];
 const isInRemotionRoot = ({ remotionRoot, fileName, }) => {
@@ -507,13 +508,31 @@ const createSequenceElement = () => {
 const createNumberAttribute = (name, value) => {
     return recast.types.builders.jsxAttribute(recast.types.builders.jsxIdentifier(name), recast.types.builders.jsxExpressionContainer(recast.types.builders.numericLiteral(value)));
 };
+const createPositionAbsoluteStyleAttribute = () => {
+    return recast.types.builders.jsxAttribute(recast.types.builders.jsxIdentifier('style'), recast.types.builders.jsxExpressionContainer(recast.types.builders.objectExpression([
+        recast.types.builders.objectProperty(recast.types.builders.identifier('position'), recast.types.builders.stringLiteral('absolute')),
+    ])));
+};
+const createStaticFileSrcAttribute = ({ staticFileLocalName, src, }) => {
+    return recast.types.builders.jsxAttribute(recast.types.builders.jsxIdentifier('src'), recast.types.builders.jsxExpressionContainer(recast.types.builders.callExpression(recast.types.builders.identifier(staticFileLocalName), [recast.types.builders.stringLiteral(src)])));
+};
 const createSolidElement = ({ localName, width, height, }) => {
     return recast.types.builders.jsxElement(recast.types.builders.jsxOpeningElement(recast.types.builders.jsxIdentifier(localName), [
         createNumberAttribute('width', width),
         createNumberAttribute('height', height),
-        recast.types.builders.jsxAttribute(recast.types.builders.jsxIdentifier('style'), recast.types.builders.jsxExpressionContainer(recast.types.builders.objectExpression([
-            recast.types.builders.objectProperty(recast.types.builders.identifier('position'), recast.types.builders.stringLiteral('absolute')),
-        ]))),
+        createPositionAbsoluteStyleAttribute(),
+    ], true), null, []);
+};
+const createAssetElement = ({ localName, staticFileLocalName, src, dimensions, }) => {
+    return recast.types.builders.jsxElement(recast.types.builders.jsxOpeningElement(recast.types.builders.jsxIdentifier(localName), [
+        createStaticFileSrcAttribute({ staticFileLocalName, src }),
+        createPositionAbsoluteStyleAttribute(),
+        ...(dimensions
+            ? [
+                createNumberAttribute('width', dimensions.width),
+                createNumberAttribute('height', dimensions.height),
+            ]
+            : []),
     ], true), null, []);
 };
 const createFragmentWithElement = (element) => {
@@ -568,12 +587,6 @@ const addElementToNullComponentReturn = ({ declaration, element, }) => {
     returnStatement.argument = createFragmentWithElement(element);
     return (_b = (_a = returnStatement.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _b !== void 0 ? _b : 1;
 };
-const getImportedName = (specifier) => {
-    if (specifier.imported.type === 'Identifier') {
-        return specifier.imported.name;
-    }
-    return specifier.imported.value;
-};
 const declarationBindsName = (declaration, name) => {
     var _a;
     if (declaration.type === 'FunctionDeclaration' ||
@@ -619,54 +632,98 @@ const getAvailableSolidLocalName = (ast) => {
     }
     return available;
 };
-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 ensureSolidImport = (ast) => {
+    return (0, imports_1.ensureNamedImport)({
+        ast,
+        importedName: 'Solid',
+        sourcePath: 'remotion',
+        localName: getAvailableSolidLocalName(ast),
+    });
+};
+const getImportDeclarations = ({ ast, sourcePath, }) => {
+    return ast.program.body.filter((node) => node.type === 'ImportDeclaration' &&
+        node.source.type === 'StringLiteral' &&
+        node.source.value === sourcePath);
 };
-const addSolidImport = ({ ast, localName, remotionImport, }) => {
+const importDeclarationHasNamespaceSpecifier = (importDeclaration) => {
     var _a;
-    var _b;
-    const imported = recast.types.builders.identifier('Solid');
-    const local = localName === 'Solid' ? null : recast.types.builders.identifier(localName);
-    const specifier = recast.types.builders.importSpecifier(imported, local);
-    const canAddToExistingRemotionImport = remotionImport &&
-        !((_a = remotionImport.specifiers) === null || _a === void 0 ? void 0 : _a.some((importSpecifier) => importSpecifier.type === 'ImportNamespaceSpecifier'));
-    if (canAddToExistingRemotionImport) {
-        remotionImport.specifiers = [
-            ...((_b = remotionImport.specifiers) !== null && _b !== void 0 ? _b : []),
-            specifier,
+    return (_a = importDeclaration.specifiers) === null || _a === void 0 ? void 0 : _a.some((specifier) => specifier.type === 'ImportNamespaceSpecifier');
+};
+const hasOfficialLocalImport = ({ ast, importedName, sourcePath, }) => {
+    return getImportDeclarations({ ast, sourcePath }).some((importDeclaration) => {
+        var _a;
+        return (_a = importDeclaration.specifiers) === null || _a === void 0 ? void 0 : _a.some((specifier) => {
+            var _a;
+            var _b;
+            return (specifier.type === 'ImportSpecifier' &&
+                (0, imports_1.getImportedName)(specifier) === importedName &&
+                ((_b = (_a = specifier.local) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : importedName) === importedName);
+        });
+    });
+};
+const addOfficialNamedImport = ({ ast, importedName, sourcePath, }) => {
+    var _a;
+    const existingImport = getImportDeclarations({ ast, sourcePath }).find((candidate) => !importDeclarationHasNamespaceSpecifier(candidate));
+    const importSpecifier = recast.types.builders.importSpecifier(recast.types.builders.identifier(importedName));
+    if (existingImport) {
+        existingImport.specifiers = [
+            ...((_a = existingImport.specifiers) !== null && _a !== void 0 ? _a : []),
+            importSpecifier,
         ];
         return;
     }
-    const importDeclaration = recast.types.builders.importDeclaration([], recast.types.builders.stringLiteral('remotion'));
-    importDeclaration.specifiers = [specifier];
-    insertImportDeclaration(ast, importDeclaration);
+    const importDeclaration = recast.types.builders.importDeclaration([importSpecifier], recast.types.builders.stringLiteral(sourcePath));
+    (0, imports_1.insertImportDeclaration)(ast, importDeclaration);
 };
-const ensureSolidImport = (ast) => {
-    var _a, _b;
-    let remotionImport = null;
-    for (const node of ast.program.body) {
-        if (node.type !== 'ImportDeclaration' || node.source.value !== 'remotion') {
-            continue;
-        }
-        remotionImport = node;
-        const solidSpecifier = (_a = node.specifiers) === null || _a === void 0 ? void 0 : _a.find((specifier) => {
-            return (specifier.type === 'ImportSpecifier' &&
-                getImportedName(specifier) === 'Solid');
-        });
-        if ((_b = solidSpecifier === null || solidSpecifier === void 0 ? void 0 : solidSpecifier.local) === null || _b === void 0 ? void 0 : _b.name) {
-            return solidSpecifier.local.name;
-        }
+const ensureOfficialNamedImport = ({ ast, importedName, sourcePath, label, }) => {
+    if (hasOfficialLocalImport({ ast, importedName, sourcePath })) {
+        return importedName;
+    }
+    if (hasTopLevelBinding({ ast, name: importedName })) {
+        throw new Error(`Cannot add ${label} because ${importedName} is already defined`);
     }
-    const localName = getAvailableSolidLocalName(ast);
-    addSolidImport({ ast, localName, remotionImport });
-    return localName;
+    addOfficialNamedImport({ ast, importedName, sourcePath });
+    return importedName;
+};
+const ensureStaticFileImport = (ast) => {
+    return ensureOfficialNamedImport({
+        ast,
+        importedName: 'staticFile',
+        sourcePath: 'remotion',
+        label: 'staticFile()',
+    });
+};
+const ensureImgImport = (ast) => {
+    return ensureOfficialNamedImport({
+        ast,
+        importedName: 'Img',
+        sourcePath: 'remotion',
+        label: '<Img>',
+    });
+};
+const ensureVideoImport = (ast) => {
+    return ensureOfficialNamedImport({
+        ast,
+        importedName: 'Video',
+        sourcePath: '@remotion/media',
+        label: '<Video>',
+    });
+};
+const ensureAudioImport = (ast) => {
+    return ensureOfficialNamedImport({
+        ast,
+        importedName: 'Audio',
+        sourcePath: '@remotion/media',
+        label: '<Audio>',
+    });
+};
+const ensureGifImport = (ast) => {
+    return ensureOfficialNamedImport({
+        ast,
+        importedName: 'Gif',
+        sourcePath: '@remotion/gif',
+        label: '<Gif>',
+    });
 };
 const addElementToComponentRoot = ({ ast, exportName, element, }) => {
     var _a;
@@ -695,7 +752,7 @@ const addElementToComponentRoot = ({ ast, exportName, element, }) => {
     if (rootNode.type === 'JSXElement' &&
         rootNode.openingElement.name.type === 'JSXIdentifier' &&
         CANVAS_ROOT_ELEMENTS.includes(rootNode.openingElement.name.name)) {
-        throw new Error(`Cannot insert a <Solid> into a composition whose root element is <${rootNode.openingElement.name.name}>`);
+        throw new Error(`Cannot insert a JSX element into a composition whose root element is <${rootNode.openingElement.name.name}>`);
     }
     if (!rootNode.children) {
         throw new Error('Composition component root does not accept children');
@@ -890,6 +947,31 @@ const createInsertableJsxElement = ({ ast, element, }) => {
             height: element.height,
         });
     }
+    if (element.type === 'asset') {
+        const staticFileLocalName = ensureStaticFileImport(ast);
+        let localName;
+        if (element.assetType === 'image') {
+            localName = ensureImgImport(ast);
+        }
+        else if (element.assetType === 'video') {
+            localName = ensureVideoImport(ast);
+        }
+        else if (element.assetType === 'gif') {
+            localName = ensureGifImport(ast);
+        }
+        else if (element.assetType === 'audio') {
+            localName = ensureAudioImport(ast);
+        }
+        else {
+            throw new Error('Unsupported asset type');
+        }
+        return createAssetElement({
+            localName,
+            staticFileLocalName,
+            src: element.src,
+            dimensions: element.dimensions,
+        });
+    }
     throw new Error('Unsupported element type');
 };
 const insertJsxElementIntoComposition = async ({ remotionRoot, compositionFile, compositionId, element, prettierConfigOverride, }) => {

package/dist/preview-server/api-routes.js

@@ -13,16 +13,22 @@ const delete_effect_1 = require("./routes/delete-effect");
 const delete_jsx_node_1 = require("./routes/delete-jsx-node");
 const delete_keyframes_1 = require("./routes/delete-keyframes");
 const delete_static_file_1 = require("./routes/delete-static-file");
+const download_remote_asset_1 = require("./routes/download-remote-asset");
 const duplicate_jsx_node_1 = require("./routes/duplicate-jsx-node");
 const insert_jsx_element_1 = require("./routes/insert-jsx-element");
 const install_dependency_1 = require("./routes/install-dependency");
+const log_studio_error_1 = require("./routes/log-studio-error");
+const move_keyframes_1 = require("./routes/move-keyframes");
 const open_in_editor_1 = require("./routes/open-in-editor");
 const open_in_file_explorer_1 = require("./routes/open-in-file-explorer");
+const paste_effects_1 = require("./routes/paste-effects");
 const project_info_1 = require("./routes/project-info");
 const redo_1 = require("./routes/redo");
 const register_client_render_1 = require("./routes/register-client-render");
 const remove_render_1 = require("./routes/remove-render");
+const rename_static_file_1 = require("./routes/rename-static-file");
 const reorder_effect_1 = require("./routes/reorder-effect");
+const reorder_sequence_1 = require("./routes/reorder-sequence");
 const restart_studio_1 = require("./routes/restart-studio");
 const save_effect_props_1 = require("./routes/save-effect-props");
 const save_sequence_props_1 = require("./routes/save-sequence-props");
@@ -36,6 +42,8 @@ const unsubscribe_from_file_existence_1 = require("./routes/unsubscribe-from-fil
 const unsubscribe_from_sequence_props_1 = require("./routes/unsubscribe-from-sequence-props");
 const update_available_1 = require("./routes/update-available");
 const update_default_props_1 = require("./routes/update-default-props");
+const update_effect_keyframe_settings_1 = require("./routes/update-effect-keyframe-settings");
+const update_sequence_keyframe_settings_1 = require("./routes/update-sequence-keyframe-settings");
 exports.allApiRoutes = {
     '/api/composition-component-info': composition_component_info_1.compositionComponentInfoHandler,
     '/api/cancel': cancel_render_1.handleCancelRender,
@@ -58,18 +66,26 @@ exports.allApiRoutes = {
     '/api/save-effect-props': save_effect_props_1.saveEffectPropsHandler,
     '/api/add-effect': add_effect_1.addEffectHandler,
     '/api/reorder-effect': reorder_effect_1.reorderEffectHandler,
+    '/api/reorder-sequence': reorder_sequence_1.reorderSequenceHandler,
     '/api/delete-keyframes': delete_keyframes_1.deleteKeyframesHandler,
+    '/api/move-keyframes': move_keyframes_1.moveKeyframesHandler,
     '/api/add-sequence-keyframe': add_sequence_keyframe_1.addSequenceKeyframeHandler,
     '/api/add-effect-keyframe': add_effect_keyframe_1.addEffectKeyframeHandler,
+    '/api/update-sequence-keyframe-settings': update_sequence_keyframe_settings_1.updateSequenceKeyframeSettingsHandler,
+    '/api/update-effect-keyframe-settings': update_effect_keyframe_settings_1.updateEffectKeyframeSettingsHandler,
     '/api/delete-effect': delete_effect_1.deleteEffectHandler,
+    '/api/paste-effects': paste_effects_1.pasteEffectsHandler,
     '/api/delete-jsx-node': delete_jsx_node_1.deleteJsxNodeHandler,
     '/api/duplicate-jsx-node': duplicate_jsx_node_1.duplicateJsxNodeHandler,
     '/api/update-available': update_available_1.handleUpdate,
     '/api/project-info': project_info_1.projectInfoHandler,
     '/api/delete-static-file': delete_static_file_1.deleteStaticFileHandler,
+    '/api/rename-static-file': rename_static_file_1.renameStaticFileHandler,
     '/api/restart-studio': restart_studio_1.handleRestartStudio,
     '/api/install-package': install_dependency_1.handleInstallPackage,
     '/api/insert-jsx-element': insert_jsx_element_1.insertJsxElementHandler,
+    '/api/download-remote-asset': download_remote_asset_1.downloadRemoteAssetHandler,
     '/api/undo': undo_1.undoHandler,
     '/api/redo': redo_1.redoHandler,
+    '/api/log-studio-error': log_studio_error_1.logStudioErrorHandler,
 };

package/dist/preview-server/routes/add-effect-keyframe.js

@@ -27,6 +27,7 @@ const addEffectKeyframeHandler = ({ input: { fileName, sequenceNodePath, effectI
         input: fileContents,
         sequenceNodePath: sequenceNodePath.nodePath,
         effectIndex,
+        schema,
         updates: [
             {
                 key,
@@ -83,6 +84,7 @@ const addEffectKeyframeHandler = ({ input: { fileName, sequenceNodePath, effectI
         };
     }
     return (0, can_update_effect_props_1.computeEffectPropStatus)({
+        ast,
         jsx,
         effectIndex,
         keys: (0, studio_shared_1.getAllSchemaKeys)(schema),

package/dist/preview-server/routes/add-sequence-keyframe.js

@@ -24,6 +24,7 @@ const addSequenceKeyframeHandler = ({ input: { fileName, nodePath, key, frame, v
     const { output, oldValueStrings, newValueStrings, formatted, logLine, updatedNodePath, } = await (0, update_keyframes_1.updateSequenceKeyframes)({
         input: fileContents,
         nodePath: nodePath.nodePath,
+        schema,
         updates: [
             {
                 key,

package/dist/preview-server/routes/apply-codemod.js

@@ -37,6 +37,24 @@ const getCodemodUndoDescription = (codemod) => {
             entryType: codemod.type,
         };
     }
+    if (codemod.type === 'delete-folder') {
+        const label = `folder "${codemod.parentName ? `${codemod.parentName}/` : ''}${codemod.folderName}"`;
+        return {
+            undoMessage: `↩️  Deletion of ${label}`,
+            redoMessage: `↪️  Deletion of ${label}`,
+            entryType: codemod.type,
+        };
+    }
+    if (codemod.type === 'rename-folder') {
+        const oldName = `${codemod.parentName ? `${codemod.parentName}/` : ''}${codemod.folderName}`;
+        const newName = `${codemod.parentName ? `${codemod.parentName}/` : ''}${codemod.newName}`;
+        const label = `folder "${oldName}" to "${newName}"`;
+        return {
+            undoMessage: `↩️  Rename of ${label}`,
+            redoMessage: `↪️  Rename of ${label}`,
+            entryType: codemod.type,
+        };
+    }
     return {
         undoMessage: '↩️  Visual control change',
         redoMessage: '↪️  Visual control change',