@remotion/studio-server 4.0.461 → 4.0.463

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

@@ -0,0 +1,52 @@
+import type { ArrayExpression, CallExpression, JSXAttribute } from '@babel/types';
+import type { SequenceNodePath } from 'remotion';
+export type EffectPropUpdate = {
+    key: string;
+    value: unknown;
+    defaultValue: unknown | null;
+};
+export type UpdateEffectPropsResult = {
+    output: string;
+    formatted: boolean;
+    oldValueString: string;
+    logLine: number;
+    effectCallee: string;
+};
+export type EffectArrayElement = {
+    kind: 'call';
+    callee: string;
+    node: CallExpression;
+} | {
+    kind: 'unsupported';
+    reason: 'not-call-expression' | 'spread';
+};
+export declare const enumerateEffectArrayElements: (arr: ArrayExpression) => EffectArrayElement[];
+export declare const findEffectCallExpression: ({ attr, effectIndex, }: {
+    attr: JSXAttribute;
+    effectIndex: number;
+}) => {
+    kind: "ok";
+    call: CallExpression;
+    callee: string;
+} | {
+    kind: "error";
+    reason: "not-call-expression" | "not-found";
+};
+export declare const updateEffectPropsAst: ({ input, sequenceNodePath, effectIndex, update, }: {
+    input: string;
+    sequenceNodePath: SequenceNodePath;
+    effectIndex: number;
+    update: EffectPropUpdate;
+}) => {
+    serialized: string;
+    oldValueString: string;
+    logLine: number;
+    effectCallee: string;
+};
+export declare const updateEffectProps: ({ input, sequenceNodePath, effectIndex, update, prettierConfigOverride, }: {
+    input: string;
+    sequenceNodePath: SequenceNodePath;
+    effectIndex: number;
+    update: EffectPropUpdate;
+    prettierConfigOverride?: Record<string, unknown> | null | undefined;
+}) => Promise<UpdateEffectPropsResult>;

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

@@ -0,0 +1,229 @@
+"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.updateEffectProps = exports.updateEffectPropsAst = exports.findEffectCallExpression = exports.enumerateEffectArrayElements = 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 b = recast.types.builders;
+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 prop value expression');
+    }
+    return stmt.expression.right;
+};
+const findExperimentalEffectsAttr = (attrs) => {
+    for (const attr of attrs) {
+        if (attr.type !== 'JSXAttribute') {
+            continue;
+        }
+        const a = attr;
+        if (a.name.type === 'JSXIdentifier' &&
+            a.name.name === '_experimentalEffects') {
+            return a;
+        }
+    }
+    return null;
+};
+const getCalleeName = (call) => {
+    const { callee } = call;
+    if (callee.type === 'Identifier') {
+        return callee.name;
+    }
+    if (callee.type === 'MemberExpression' &&
+        !callee.computed &&
+        callee.property.type === 'Identifier') {
+        return callee.property.name;
+    }
+    return null;
+};
+const enumerateEffectArrayElements = (arr) => {
+    const out = [];
+    for (const el of arr.elements) {
+        if (el === null) {
+            out.push({ kind: 'unsupported', reason: 'not-call-expression' });
+            continue;
+        }
+        if (el.type === 'SpreadElement') {
+            out.push({ kind: 'unsupported', reason: 'spread' });
+            continue;
+        }
+        if (el.type !== 'CallExpression') {
+            out.push({ kind: 'unsupported', reason: 'not-call-expression' });
+            continue;
+        }
+        const call = el;
+        const callee = getCalleeName(call);
+        if (callee === null) {
+            out.push({ kind: 'unsupported', reason: 'not-call-expression' });
+            continue;
+        }
+        out.push({ kind: 'call', callee, node: call });
+    }
+    return out;
+};
+exports.enumerateEffectArrayElements = enumerateEffectArrayElements;
+const findEffectCallExpression = ({ attr, effectIndex, }) => {
+    if (!attr.value || attr.value.type !== 'JSXExpressionContainer') {
+        return { kind: 'error', reason: 'not-call-expression' };
+    }
+    const expr = attr.value.expression;
+    if (expr.type !== 'ArrayExpression') {
+        return { kind: 'error', reason: 'not-call-expression' };
+    }
+    const elements = (0, exports.enumerateEffectArrayElements)(expr);
+    if (effectIndex < 0 || effectIndex >= elements.length) {
+        return { kind: 'error', reason: 'not-found' };
+    }
+    const target = elements[effectIndex];
+    if (target.kind !== 'call') {
+        return { kind: 'error', reason: 'not-call-expression' };
+    }
+    return { kind: 'ok', call: target.node, callee: target.callee };
+};
+exports.findEffectCallExpression = findEffectCallExpression;
+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 updateEffectPropsAst = ({ input, sequenceNodePath, effectIndex, update, }) => {
+    var _a, _b, _c, _d;
+    var _e, _f, _g, _h, _j;
+    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 update effects');
+    }
+    const attr = findExperimentalEffectsAttr((_e = jsx.attributes) !== null && _e !== void 0 ? _e : []);
+    if (!attr) {
+        throw new Error('Could not find _experimentalEffects on the target JSX element');
+    }
+    const found = (0, exports.findEffectCallExpression)({
+        attr,
+        effectIndex,
+    });
+    if (found.kind === 'error') {
+        throw new Error(`Cannot update effect prop: ${found.reason}`);
+    }
+    const { call, callee: effectCallee } = found;
+    const isDefault = update.defaultValue !== null &&
+        JSON.stringify(update.value) === JSON.stringify(update.defaultValue);
+    let objExpr;
+    if (call.arguments.length === 0) {
+        if (isDefault) {
+            return {
+                serialized: (0, parse_ast_1.serializeAst)(ast),
+                oldValueString: '',
+                logLine: (_g = (_f = (_a = call.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _f !== void 0 ? _f : (_b = jsx.loc) === null || _b === void 0 ? void 0 : _b.start.line) !== null && _g !== void 0 ? _g : 1,
+                effectCallee,
+            };
+        }
+        objExpr = b.objectExpression([]);
+        call.arguments.push(objExpr);
+    }
+    else if (call.arguments[0].type !== 'ObjectExpression') {
+        throw new Error('Cannot update effect prop: computed');
+    }
+    else {
+        objExpr = call.arguments[0];
+    }
+    const { prop } = findObjectProperty(objExpr, update.key);
+    let oldValueString = '';
+    if (prop) {
+        oldValueString = recast.print(prop.value).code;
+    }
+    else if (update.defaultValue !== null) {
+        oldValueString = JSON.stringify(update.defaultValue);
+    }
+    if (isDefault) {
+        if (prop) {
+            const idx = objExpr.properties.indexOf(prop);
+            if (idx !== -1) {
+                objExpr.properties.splice(idx, 1);
+            }
+        }
+    }
+    else {
+        const newValueExpr = parseValueExpression(update.value);
+        if (prop) {
+            prop.value = newValueExpr;
+        }
+        else {
+            objExpr.properties.push(b.objectProperty(b.identifier(update.key), newValueExpr));
+        }
+    }
+    const logLine = (_j = (_h = (_c = call.loc) === null || _c === void 0 ? void 0 : _c.start.line) !== null && _h !== void 0 ? _h : (_d = jsx.loc) === null || _d === void 0 ? void 0 : _d.start.line) !== null && _j !== void 0 ? _j : 1;
+    return {
+        serialized: (0, parse_ast_1.serializeAst)(ast),
+        oldValueString,
+        logLine,
+        effectCallee,
+    };
+};
+exports.updateEffectPropsAst = updateEffectPropsAst;
+const updateEffectProps = async ({ input, sequenceNodePath, effectIndex, update, prettierConfigOverride, }) => {
+    const { serialized, oldValueString, logLine, effectCallee } = (0, exports.updateEffectPropsAst)({
+        input,
+        sequenceNodePath,
+        effectIndex,
+        update,
+    });
+    const { output, formatted } = await (0, format_file_content_1.formatFileContent)({
+        input: serialized,
+        prettierConfigOverride,
+    });
+    return {
+        output,
+        oldValueString,
+        formatted,
+        logLine,
+        effectCallee,
+    };
+};
+exports.updateEffectProps = updateEffectProps;

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

@@ -14,6 +14,7 @@ const project_info_1 = require("./routes/project-info");
 const redo_1 = require("./routes/redo");
 const remove_render_1 = require("./routes/remove-render");
 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");
 const subscribe_to_default_props_1 = require("./routes/subscribe-to-default-props");
 const subscribe_to_file_existence_1 = require("./routes/subscribe-to-file-existence");
@@ -39,6 +40,7 @@ exports.allApiRoutes = {
     '/api/subscribe-to-sequence-props': subscribe_to_sequence_props_1.subscribeToSequenceProps,
     '/api/unsubscribe-from-sequence-props': unsubscribe_from_sequence_props_1.unsubscribeFromSequenceProps,
     '/api/save-sequence-props': save_sequence_props_1.saveSequencePropsHandler,
+    '/api/save-effect-props': save_effect_props_1.saveEffectPropsHandler,
     '/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,

package/dist/preview-server/jsx-element-not-found-at-location-error.d.ts

@@ -0,0 +1,3 @@
+export declare class JsxElementNotFoundAtLocationError extends Error {
+    constructor();
+}

package/dist/preview-server/jsx-element-not-found-at-location-error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsxElementNotFoundAtLocationError = void 0;
+class JsxElementNotFoundAtLocationError extends Error {
+    constructor() {
+        super('Cannot compute sequence props status: Could not find a JSX element at the specified location');
+        this.name = 'JsxElementNotFoundAtLocationError';
+    }
+}
+exports.JsxElementNotFoundAtLocationError = JsxElementNotFoundAtLocationError;

package/dist/preview-server/project-info.js

@@ -6,8 +6,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProjectInfo = void 0;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
+const getRootFileFromEntryPoint = (entryPoint) => {
+    const entryBase = node_path_1.default.basename(entryPoint, node_path_1.default.extname(entryPoint));
+    if (!entryBase.endsWith('-entry')) {
+        return null;
+    }
+    const stem = entryBase.slice(0, -'-entry'.length);
+    const pascalCase = stem
+        .split('-')
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+    const rootName = `${pascalCase}Root`;
+    const entryDir = node_path_1.default.dirname(entryPoint);
+    for (const ext of ['.tsx', '.ts', '.jsx', '.js']) {
+        const candidate = node_path_1.default.join(entryDir, rootName + ext);
+        if ((0, node_fs_1.existsSync)(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+};
 const getProjectInfo = (remotionRoot, entryPoint) => {
     var _a;
+    const rootFileFromEntryPoint = getRootFileFromEntryPoint(entryPoint);
+    if (rootFileFromEntryPoint) {
+        return Promise.resolve({
+            rootFile: rootFileFromEntryPoint,
+            relativeRootFile: node_path_1.default.relative(remotionRoot, rootFileFromEntryPoint),
+        });
+    }
     const knownPaths = [
         'src/Root.tsx',
         'src/Root.jsx',

package/dist/preview-server/routes/can-update-effect-props.d.ts

@@ -0,0 +1,20 @@
+import type { JSXOpeningElement } from '@babel/types';
+import type { CanUpdateEffectPropsResponse, SequenceNodePath, SequenceSchema } from 'remotion';
+export declare const computeEffectPropStatus: ({ jsx, effectIndex, keys, }: {
+    jsx: JSXOpeningElement;
+    effectIndex: number;
+    keys: string[];
+}) => CanUpdateEffectPropsResponse;
+export declare const computeEffectPropsStatusesFromContent: ({ fileContents, sequenceNodePath, effects, keysFor, }: {
+    fileContents: string;
+    sequenceNodePath: SequenceNodePath;
+    effects: SequenceSchema[];
+    keysFor: (effect: SequenceSchema) => string[];
+}) => CanUpdateEffectPropsResponse[];
+export declare const computeEffectPropsStatusesFromFile: ({ fileName, sequenceNodePath, effects, keysFor, remotionRoot, }: {
+    fileName: string;
+    sequenceNodePath: SequenceNodePath;
+    effects: SequenceSchema[];
+    keysFor: (effect: SequenceSchema) => string[];
+    remotionRoot: string;
+}) => CanUpdateEffectPropsResponse[];

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

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeEffectPropsStatusesFromFile = exports.computeEffectPropsStatusesFromContent = exports.computeEffectPropStatus = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const parse_ast_1 = require("../../codemods/parse-ast");
+const update_effect_props_1 = require("../../codemods/update-effect-props/update-effect-props");
+const can_update_sequence_props_1 = require("./can-update-sequence-props");
+const findExperimentalEffectsAttr = (jsx) => {
+    for (const attr of jsx.attributes) {
+        if (attr.type !== 'JSXAttribute') {
+            continue;
+        }
+        if (attr.name.type === 'JSXIdentifier' &&
+            attr.name.name === '_experimentalEffects') {
+            return attr;
+        }
+    }
+    return null;
+};
+const getEffectsArrayElements = (attr) => {
+    if (!attr || !attr.value || attr.value.type !== 'JSXExpressionContainer') {
+        return null;
+    }
+    const expr = attr.value.expression;
+    if (expr.type !== 'ArrayExpression') {
+        return null;
+    }
+    return (0, update_effect_props_1.enumerateEffectArrayElements)(expr);
+};
+const getPropsFromObjectExpression = ({ objExpr, keys, }) => {
+    const out = {};
+    for (const key of keys) {
+        const prop = objExpr.properties.find((p) => p.type === 'ObjectProperty' &&
+            ((p.key.type === 'Identifier' && p.key.name === key) ||
+                (p.key.type === 'StringLiteral' &&
+                    p.key.value === key)));
+        if (!prop) {
+            out[key] = { canUpdate: true, codeValue: undefined };
+            continue;
+        }
+        const valueExpr = prop.value;
+        if (!(0, can_update_sequence_props_1.isStaticValue)(valueExpr)) {
+            out[key] = { canUpdate: false, reason: 'computed' };
+            continue;
+        }
+        out[key] = {
+            canUpdate: true,
+            codeValue: (0, can_update_sequence_props_1.extractStaticValue)(valueExpr),
+        };
+    }
+    return out;
+};
+const computeEffectPropStatus = ({ jsx, effectIndex, keys, }) => {
+    const attr = findExperimentalEffectsAttr(jsx);
+    const elements = getEffectsArrayElements(attr);
+    if (!elements) {
+        return {
+            canUpdate: false,
+            effectIndex,
+            reason: 'not-found',
+        };
+    }
+    if (effectIndex < 0 || effectIndex >= elements.length) {
+        return {
+            canUpdate: false,
+            effectIndex,
+            reason: 'not-found',
+        };
+    }
+    const target = elements[effectIndex];
+    if (target.kind !== 'call') {
+        return {
+            canUpdate: false,
+            effectIndex,
+            reason: 'not-call-expression',
+        };
+    }
+    const call = target.node;
+    if (call.arguments.length === 0) {
+        const emptyProps = {};
+        for (const key of keys) {
+            emptyProps[key] = { canUpdate: true, codeValue: undefined };
+        }
+        return {
+            canUpdate: true,
+            callee: target.callee,
+            effectIndex,
+            props: emptyProps,
+        };
+    }
+    const firstArg = call.arguments[0];
+    if (firstArg.type !== 'ObjectExpression') {
+        return {
+            canUpdate: false,
+            effectIndex,
+            reason: 'computed',
+        };
+    }
+    const resolvedProps = getPropsFromObjectExpression({
+        objExpr: firstArg,
+        keys,
+    });
+    return {
+        canUpdate: true,
+        effectIndex,
+        callee: target.callee,
+        props: resolvedProps,
+    };
+};
+exports.computeEffectPropStatus = computeEffectPropStatus;
+const computeEffectPropsStatusesFromContent = ({ fileContents, sequenceNodePath, effects, keysFor, }) => {
+    const ast = (0, parse_ast_1.parseAst)(fileContents);
+    const jsx = (0, can_update_sequence_props_1.findJsxElementAtNodePath)(ast, sequenceNodePath);
+    if (!jsx) {
+        return effects.map((_effect, effectIndex) => ({
+            canUpdate: false,
+            effectIndex,
+            reason: 'not-found',
+        }));
+    }
+    return effects.map((effect, effectIndex) => (0, exports.computeEffectPropStatus)({
+        jsx,
+        effectIndex,
+        keys: keysFor(effect),
+    }));
+};
+exports.computeEffectPropsStatusesFromContent = computeEffectPropsStatusesFromContent;
+const computeEffectPropsStatusesFromFile = ({ fileName, sequenceNodePath, effects, keysFor, remotionRoot, }) => {
+    const absolutePath = node_path_1.default.resolve(remotionRoot, fileName);
+    const fileRelativeToRoot = node_path_1.default.relative(remotionRoot, absolutePath);
+    if (fileRelativeToRoot.startsWith('..')) {
+        throw new Error('Cannot read a file outside the project');
+    }
+    const fileContents = (0, node_fs_1.readFileSync)(absolutePath, 'utf-8');
+    return (0, exports.computeEffectPropsStatusesFromContent)({
+        fileContents,
+        sequenceNodePath,
+        effects,
+        keysFor,
+    });
+};
+exports.computeEffectPropsStatusesFromFile = computeEffectPropsStatusesFromFile;

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

@@ -2,20 +2,38 @@ import type { Expression, File, JSXOpeningElement } from '@babel/types';
 import type { SubscribeToSequencePropsResponse } from '@remotion/studio-shared';
 import type { CanUpdateSequencePropsResponseTrue } from 'remotion';
 import type { SequenceNodePath } from 'remotion';
+import type { CanUpdateSequencePropStatus } from 'remotion';
 export declare const isStaticValue: (node: Expression) => boolean;
 export declare const extractStaticValue: (node: Expression) => unknown;
 export declare const findJsxElementAtNodePath: (ast: File, nodePath: SequenceNodePath) => JSXOpeningElement | null;
 export declare const lineColumnToNodePath: (ast: File, targetLine: number) => SequenceNodePath | null;
-export declare const computeSequencePropsStatusFromContent: (fileContents: string, nodePath: SequenceNodePath, keys: string[]) => CanUpdateSequencePropsResponseTrue;
-export declare const computeSequencePropsStatus: ({ fileName, nodePath, keys, remotionRoot, }: {
+export declare const computeSequencePropsOnlyStatus: ({ fileName, nodePath, keys, remotionRoot, }: {
     fileName: string;
     nodePath: SequenceNodePath;
     keys: string[];
     remotionRoot: string;
+}) => {
+    canUpdate: true;
+    props: Record<string, CanUpdateSequencePropStatus>;
+};
+export declare const computeSequencePropsStatusFromContent: ({ fileContents, nodePath, keys, effects, }: {
+    fileContents: string;
+    nodePath: SequenceNodePath;
+    keys: string[];
+    effects: string[][];
+}) => CanUpdateSequencePropsResponseTrue;
+export declare const computeSequencePropsStatus: ({ fileName, nodePath, keys, effects, remotionRoot, }: {
+    fileName: string;
+    nodePath: SequenceNodePath;
+    keys: string[];
+    effects: string[][];
+    remotionRoot: string;
 }) => CanUpdateSequencePropsResponseTrue;
-export declare const computeSequencePropsStatusFromFilenameByLine: ({ fileName, line, keys, remotionRoot, }: {
+export declare const computeSequencePropsStatusFromFilenameByLine: ({ fileName, line, keys, effects, remotionRoot, logLevel, }: {
     fileName: string;
     line: number;
     keys: string[];
+    effects: string[][];
     remotionRoot: string;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
 }) => SubscribeToSequencePropsResponse;