@remotion/studio-server 4.0.430 → 4.0.432

package/dist/codemods/update-nested-prop.d.ts

@@ -0,0 +1,13 @@
+import { type EnumPath } from '@remotion/studio-shared';
+import type { namedTypes } from 'ast-types';
+import type { ExpressionKind } from 'ast-types/lib/gen/kinds';
+export declare const parseValueExpression: (value: unknown, enumPaths: EnumPath[]) => ExpressionKind;
+export declare const updateNestedProp: ({ node, parentKey, childKey, value, enumPaths, defaultValue, isDefault, }: {
+    node: namedTypes.JSXOpeningElement;
+    parentKey: string;
+    childKey: string;
+    value: unknown;
+    enumPaths: EnumPath[];
+    defaultValue: unknown;
+    isDefault: boolean;
+}) => string;

package/dist/codemods/update-nested-prop.js

@@ -0,0 +1,158 @@
+"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.updateNestedProp = exports.parseValueExpression = void 0;
+const studio_shared_1 = require("@remotion/studio-shared");
+const recast = __importStar(require("recast"));
+const parse_ast_1 = require("./parse-ast");
+const b = recast.types.builders;
+const parseValueExpression = (value, enumPaths) => {
+    return (0, parse_ast_1.parseAst)(`a = ${(0, studio_shared_1.stringifyDefaultProps)({ props: value, enumPaths })}`)
+        .program.body[0].expression.right;
+};
+exports.parseValueExpression = parseValueExpression;
+const findJsxAttribute = (attributes, name) => {
+    const attrIndex = attributes.findIndex((a) => {
+        if (a.type === 'JSXSpreadAttribute') {
+            return false;
+        }
+        if (a.name.type === 'JSXNamespacedName') {
+            return false;
+        }
+        return a.name.name === name;
+    });
+    const found = attrIndex !== -1 ? attributes[attrIndex] : undefined;
+    return {
+        attrIndex,
+        attr: found && found.type === 'JSXAttribute'
+            ? found
+            : undefined,
+    };
+};
+const findObjectProperty = (objExpr, propertyName) => {
+    const propIndex = objExpr.properties.findIndex((p) => p.type === 'ObjectProperty' &&
+        ((p.key.type === 'Identifier' &&
+            p.key.name ===
+                propertyName) ||
+            (p.key.type === 'StringLiteral' &&
+                p.key
+                    .value === propertyName)));
+    return {
+        propIndex,
+        prop: propIndex !== -1
+            ? objExpr.properties[propIndex]
+            : undefined,
+    };
+};
+const getObjectExpression = (attr) => {
+    const { value } = attr;
+    if (!value || value.type !== 'JSXExpressionContainer') {
+        return null;
+    }
+    const container = value;
+    if (container.expression.type !== 'ObjectExpression') {
+        return null;
+    }
+    return container.expression;
+};
+const getOldValueString = ({ attr, childKey, defaultValue, }) => {
+    if (attr) {
+        const objExpr = getObjectExpression(attr);
+        if (objExpr) {
+            const { prop } = findObjectProperty(objExpr, childKey);
+            if (prop) {
+                return recast.print(prop.value).code;
+            }
+        }
+    }
+    if (defaultValue !== null) {
+        return JSON.stringify(defaultValue);
+    }
+    return '';
+};
+const removeNestedProp = ({ attr, attrIndex, attributes, childKey, }) => {
+    if (!attr) {
+        return;
+    }
+    const objExpr = getObjectExpression(attr);
+    if (!objExpr) {
+        return;
+    }
+    const { propIndex } = findObjectProperty(objExpr, childKey);
+    if (propIndex !== -1) {
+        objExpr.properties.splice(propIndex, 1);
+    }
+    if (objExpr.properties.length === 0 && attrIndex !== -1) {
+        attributes.splice(attrIndex, 1);
+    }
+};
+const setNestedProp = ({ attr, attributes, parentKey, childKey, value, enumPaths, }) => {
+    const parsedValue = (0, exports.parseValueExpression)(value, enumPaths);
+    if (attr) {
+        const objExpr = getObjectExpression(attr);
+        if (objExpr) {
+            const { prop } = findObjectProperty(objExpr, childKey);
+            if (prop) {
+                prop.value = parsedValue;
+            }
+            else {
+                objExpr.properties.push(b.objectProperty(b.identifier(childKey), parsedValue));
+            }
+        }
+    }
+    else {
+        const objExpr = b.objectExpression([
+            b.objectProperty(b.identifier(childKey), parsedValue),
+        ]);
+        const newAttr = b.jsxAttribute(b.jsxIdentifier(parentKey), b.jsxExpressionContainer(objExpr));
+        attributes.push(newAttr);
+    }
+};
+const updateNestedProp = ({ node, parentKey, childKey, value, enumPaths, defaultValue, isDefault, }) => {
+    if (!node.attributes) {
+        node.attributes = [];
+    }
+    const { attributes } = node;
+    const { attrIndex, attr } = findJsxAttribute(attributes, parentKey);
+    const oldValueString = getOldValueString({ attr, childKey, defaultValue });
+    if (isDefault) {
+        removeNestedProp({ attr, attrIndex, attributes, childKey });
+    }
+    else {
+        setNestedProp({ attr, attributes, parentKey, childKey, value, enumPaths });
+    }
+    return oldValueString;
+};
+exports.updateNestedProp = updateNestedProp;

package/dist/codemods/update-sequence-props.d.ts

@@ -1,4 +1,4 @@
-import { type EnumPath } from '@remotion/studio-shared';
+import type { EnumPath } from '@remotion/studio-shared';
 export declare const updateSequenceProps: ({ input, targetLine, key, value, enumPaths, defaultValue, }: {
     input: string;
     targetLine: number;

package/dist/codemods/update-sequence-props.js

@@ -34,15 +34,20 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateSequenceProps = void 0;
-const studio_shared_1 = require("@remotion/studio-shared");
 const recast = __importStar(require("recast"));
 const parse_ast_1 = require("./parse-ast");
+const update_nested_prop_1 = require("./update-nested-prop");
+const b = recast.types.builders;
 const updateSequenceProps = async ({ input, targetLine, key, value, enumPaths, defaultValue, }) => {
     const ast = (0, parse_ast_1.parseAst)(input);
     let found = false;
     let oldValueString = '';
     const isDefault = defaultValue !== null &&
         JSON.stringify(value) === JSON.stringify(defaultValue);
+    const dotIndex = key.indexOf('.');
+    const isNested = dotIndex !== -1;
+    const parentKey = isNested ? key.slice(0, dotIndex) : key;
+    const childKey = isNested ? key.slice(dotIndex + 1) : '';
     recast.types.visit(ast, {
         visitJSXOpeningElement(path) {
             var _a, _b;
@@ -50,6 +55,19 @@ const updateSequenceProps = async ({ input, targetLine, key, value, enumPaths, d
             if (!node.loc || node.loc.start.line !== targetLine) {
                 return this.traverse(path);
             }
+            if (isNested) {
+                oldValueString = (0, update_nested_prop_1.updateNestedProp)({
+                    node,
+                    parentKey,
+                    childKey,
+                    value,
+                    enumPaths,
+                    defaultValue,
+                    isDefault,
+                });
+                found = true;
+                return this.traverse(path);
+            }
             const attrIndex = (_a = node.attributes) === null || _a === void 0 ? void 0 : _a.findIndex((a) => {
                 if (a.type === 'JSXSpreadAttribute') {
                     return false;
@@ -84,13 +102,10 @@ const updateSequenceProps = async ({ input, targetLine, key, value, enumPaths, d
                 found = true;
                 return this.traverse(path);
             }
-            const parsed = (0, parse_ast_1.parseAst)(`a = ${(0, studio_shared_1.stringifyDefaultProps)({ props: value, enumPaths })}`)
-                .program.body[0].expression.right;
-            const newValue = value === true
-                ? null
-                : recast.types.builders.jsxExpressionContainer(parsed);
+            const parsed = (0, update_nested_prop_1.parseValueExpression)(value, enumPaths);
+            const newValue = value === true ? null : b.jsxExpressionContainer(parsed);
             if (!attr || attr.type === 'JSXSpreadAttribute') {
-                const newAttr = recast.types.builders.jsxAttribute(recast.types.builders.jsxIdentifier(key), newValue);
+                const newAttr = b.jsxAttribute(b.jsxIdentifier(key), newValue);
                 if (!node.attributes) {
                     node.attributes = [];
                 }

package/dist/preview-server/routes/can-update-sequence-props.js

@@ -165,6 +165,37 @@ const findJsxElementAtLine = (ast, targetLine) => {
     });
     return found;
 };
+const getNestedPropStatus = (jsxElement, parentKey, childKey) => {
+    const attr = jsxElement.attributes.find((a) => a.type !== 'JSXSpreadAttribute' &&
+        a.name.type !== 'JSXNamespacedName' &&
+        a.name.name === parentKey);
+    if (!attr || !attr.value) {
+        // Parent attribute doesn't exist, nested prop can be added
+        return { canUpdate: true, codeValue: undefined };
+    }
+    if (attr.value.type !== 'JSXExpressionContainer') {
+        return { canUpdate: false, reason: 'computed' };
+    }
+    const { expression } = attr.value;
+    if (expression.type === 'JSXEmptyExpression' ||
+        expression.type !== 'ObjectExpression') {
+        // Parent is not an object literal (e.g. style={myStyles})
+        return { canUpdate: false, reason: 'computed' };
+    }
+    const objExpr = expression;
+    const prop = objExpr.properties.find((p) => p.type === 'ObjectProperty' &&
+        ((p.key.type === 'Identifier' && p.key.name === childKey) ||
+            (p.key.type === 'StringLiteral' && p.key.value === childKey)));
+    if (!prop) {
+        // Property not set in the object, can be added
+        return { canUpdate: true, codeValue: undefined };
+    }
+    const propValue = prop.value;
+    if (!(0, exports.isStaticValue)(propValue)) {
+        return { canUpdate: false, reason: 'computed' };
+    }
+    return { canUpdate: true, codeValue: (0, exports.extractStaticValue)(propValue) };
+};
 const computeSequencePropsStatus = ({ fileName, line, keys, remotionRoot, }) => {
     try {
         const absolutePath = node_path_1.default.resolve(remotionRoot, fileName);
@@ -181,7 +212,11 @@ const computeSequencePropsStatus = ({ fileName, line, keys, remotionRoot, }) =>
         const allProps = getPropsStatus(jsxElement);
         const filteredProps = {};
         for (const key of keys) {
-            if (key in allProps) {
+            const dotIndex = key.indexOf('.');
+            if (dotIndex !== -1) {
+                filteredProps[key] = getNestedPropStatus(jsxElement, key.slice(0, dotIndex), key.slice(dotIndex + 1));
+            }
+            else if (key in allProps) {
                 filteredProps[key] = allProps[key];
             }
             else {

package/package.json

@@ -3,7 +3,7 @@
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/studio-server"
 	},
 	"name": "@remotion/studio-server",
-	"version": "4.0.430",
+	"version": "4.0.432",
 	"description": "Run a Remotion Studio with a server backend",
 	"main": "dist",
 	"sideEffects": false,
@@ -27,11 +27,11 @@
 		"@babel/parser": "7.24.1",
 		"semver": "7.5.3",
 		"prettier": "3.8.1",
-		"remotion": "4.0.429",
+		"remotion": "4.0.432",
 		"recast": "0.23.11",
-		"@remotion/bundler": "4.0.429",
-		"@remotion/renderer": "4.0.429",
-		"@remotion/studio-shared": "4.0.429",
+		"@remotion/bundler": "4.0.432",
+		"@remotion/renderer": "4.0.432",
+		"@remotion/studio-shared": "4.0.432",
 		"memfs": "3.4.3",
 		"source-map": "0.7.3",
 		"open": "^8.4.2"
@@ -41,10 +41,10 @@
 		"react": "19.2.3",
 		"@babel/types": "7.24.0",
 		"@types/semver": "^7.3.4",
-		"@remotion/eslint-config-internal": "4.0.429",
+		"@remotion/eslint-config-internal": "4.0.432",
 		"eslint": "9.19.0",
 		"@types/node": "20.12.14",
-		"@typescript/native-preview": "7.0.0-dev.20260217.1"
+		"@typescript/native-preview": "7.0.0-dev.20260301.1"
 	},
 	"exports": {
 		".": "./dist/index.js",

package/dist/preview-server/__tests__/multiple-lockfiles.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/preview-server/__tests__/multiple-lockfiles.test.js

@@ -1,64 +0,0 @@
-'use strict';
-var __importDefault =
-	(this && this.__importDefault) ||
-	function (mod) {
-		return mod && mod.__esModule ? mod : {default: mod};
-	};
-Object.defineProperty(exports, '__esModule', {value: true});
-const bun_test_1 = require('bun:test');
-const node_fs_1 = __importDefault(require('node:fs'));
-const node_os_1 = __importDefault(require('node:os'));
-const node_path_1 = __importDefault(require('node:path'));
-const get_package_manager_1 = require('../get-package-manager');
-(0, bun_test_1.describe)('getPackageManager multiple lockfiles', () => {
-	let tempDir;
-	(0, bun_test_1.beforeEach)(() => {
-		tempDir = node_fs_1.default.mkdtempSync(
-			node_path_1.default.join(node_os_1.default.tmpdir(), 'remotion-test-'),
-		);
-	});
-	(0, bun_test_1.afterEach)(() => {
-		node_fs_1.default.rmSync(tempDir, {recursive: true, force: true});
-	});
-	(0, bun_test_1.test)(
-		'should not throw error when multiple lockfiles are detected',
-		() => {
-			node_fs_1.default.writeFileSync(
-				node_path_1.default.join(tempDir, 'package-lock.json'),
-				'{}',
-			);
-			node_fs_1.default.writeFileSync(
-				node_path_1.default.join(tempDir, 'bun.lock'),
-				'',
-			);
-			// Should not throw
-			const manager = (0, get_package_manager_1.getPackageManager)(
-				tempDir,
-				undefined,
-				0,
-			);
-			// Should return one of them (usually the first one in the list, which is npm)
-			(0, bun_test_1.expect)(manager).not.toBe('unknown');
-			if (typeof manager !== 'string') {
-				(0, bun_test_1.expect)(['npm', 'bun']).toContain(manager.manager);
-			}
-		},
-	);
-	(0, bun_test_1.test)(
-		'should return npm if only package-lock.json exists',
-		() => {
-			node_fs_1.default.writeFileSync(
-				node_path_1.default.join(tempDir, 'package-lock.json'),
-				'{}',
-			);
-			const manager = (0, get_package_manager_1.getPackageManager)(
-				tempDir,
-				undefined,
-				0,
-			);
-			if (typeof manager !== 'string') {
-				(0, bun_test_1.expect)(manager.manager).toBe('npm');
-			}
-		},
-	);
-});