@remotion/studio-server 4.0.460 → 4.0.462

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/codemods/update-sequence-props/find-props-to-delete.d.ts

@@ -0,0 +1,6 @@
+import type { SequenceSchema } from 'remotion';
+export declare const findPropsToDelete: ({ schema, key, value, }: {
+    schema: SequenceSchema;
+    key: string;
+    value: unknown;
+}) => string[];

package/dist/codemods/update-sequence-props/find-props-to-delete.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPropsToDelete = void 0;
+const findPropsToDelete = ({ schema, key, value, }) => {
+    const fieldSchema = schema[key];
+    if (!fieldSchema) {
+        throw new Error('Key ' + JSON.stringify(key) + ' not found in schema');
+    }
+    if (typeof value !== 'string') {
+        throw new Error('Value must be a string, but is ' + JSON.stringify(value));
+    }
+    if (fieldSchema.type !== 'enum') {
+        throw new Error('Key ' + JSON.stringify(key) + ' is not an enum');
+    }
+    const currentVariant = fieldSchema.variants[value];
+    if (!currentVariant) {
+        throw new Error('Value for ' +
+            JSON.stringify(key) +
+            ' must be one of ' +
+            Object.keys(fieldSchema.variants)
+                .map((v) => JSON.stringify(v))
+                .join(', ') +
+            ', got ' +
+            JSON.stringify(value));
+    }
+    const otherVariants = Object.keys(fieldSchema.variants).filter((v) => v !== value);
+    const otherKeys = new Set();
+    for (const variant of otherVariants) {
+        const otherVariant = fieldSchema.variants[variant];
+        const keys = Object.keys(otherVariant);
+        for (const k of keys) {
+            otherKeys.add(k);
+        }
+    }
+    return [...otherKeys];
+};
+exports.findPropsToDelete = findPropsToDelete;

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

@@ -0,0 +1,35 @@
+import type { SequenceNodePath } from 'remotion';
+import type { SequenceSchema } from 'remotion';
+export type SequencePropUpdate = {
+    key: string;
+    value: unknown;
+    defaultValue: unknown | null;
+};
+export type RemovedProp = {
+    key: string;
+    valueString: string;
+};
+export declare const updateSequencePropsAst: ({ input, nodePath, updates, schema, }: {
+    input: string;
+    nodePath: SequenceNodePath;
+    updates: SequencePropUpdate[];
+    schema: SequenceSchema;
+}) => {
+    serialized: string;
+    oldValueStrings: string[];
+    logLine: number;
+    removedProps: RemovedProp[];
+};
+export declare const updateSequenceProps: ({ input, nodePath, updates, schema, prettierConfigOverride, }: {
+    input: string;
+    nodePath: SequenceNodePath;
+    updates: SequencePropUpdate[];
+    schema: SequenceSchema;
+    prettierConfigOverride?: Record<string, unknown> | null | undefined;
+}) => Promise<{
+    output: string;
+    oldValueStrings: string[];
+    formatted: boolean;
+    logLine: number;
+    removedProps: RemovedProp[];
+}>;

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

@@ -0,0 +1,224 @@
+"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.updateSequenceProps = exports.updateSequencePropsAst = void 0;
+const recast = __importStar(require("recast"));
+const no_react_1 = require("remotion/no-react");
+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_nested_prop_1 = require("../update-nested-prop");
+const b = recast.types.builders;
+const removeVariantKey = ({ node, variantKey, }) => {
+    var _a;
+    const dotIndex = variantKey.indexOf('.');
+    if (dotIndex === -1) {
+        const idx = (_a = node.attributes) === null || _a === void 0 ? void 0 : _a.findIndex((a) => a.type === 'JSXAttribute' &&
+            a.name.type === 'JSXIdentifier' &&
+            a.name.name === variantKey);
+        if (idx !== undefined && idx !== -1 && node.attributes) {
+            node.attributes.splice(idx, 1);
+        }
+        return;
+    }
+    (0, update_nested_prop_1.updateNestedProp)({
+        node,
+        parentKey: variantKey.slice(0, dotIndex),
+        childKey: variantKey.slice(dotIndex + 1),
+        value: undefined,
+        defaultValue: null,
+        isDefault: true,
+    });
+};
+const snapshotTopLevelAttrs = (node) => {
+    var _a;
+    const result = new Map();
+    for (const a of (_a = node.attributes) !== null && _a !== void 0 ? _a : []) {
+        if (a.type === 'JSXAttribute' && a.name.type === 'JSXIdentifier') {
+            const { name } = a.name;
+            const printed = recast
+                .print(a)
+                .code.replace(/\s+/g, ' ')
+                .replace(/,(\s*[}\]])/g, '$1')
+                .trim();
+            const prefix = `${name}=`;
+            let valueOnly = printed.startsWith(prefix)
+                ? printed.slice(prefix.length)
+                : printed;
+            if (valueOnly.startsWith('{') && valueOnly.endsWith('}')) {
+                valueOnly = valueOnly.slice(1, -1).trim();
+            }
+            result.set(name, valueOnly);
+        }
+    }
+    return result;
+};
+const updateSequencePropsAst = ({ input, nodePath, updates, schema, }) => {
+    var _a, _b, _c;
+    var _d, _e;
+    const ast = (0, parse_ast_1.parseAst)(input);
+    const node = (0, can_update_sequence_props_1.findJsxElementAtNodePath)(ast, nodePath);
+    if (!node) {
+        throw new Error('Could not find a JSX element at the specified line to update');
+    }
+    const logLine = (_d = (_a = node.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _d !== void 0 ? _d : 1;
+    const oldValueStrings = [];
+    const initialAttrs = snapshotTopLevelAttrs(node);
+    const updatedTopLevelKeys = new Set(updates.map(({ key }) => {
+        const dot = key.indexOf('.');
+        return dot === -1 ? key : key.slice(0, dot);
+    }));
+    for (const { key, value, defaultValue } of updates) {
+        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) : '';
+        if (isNested) {
+            oldValueString = (0, update_nested_prop_1.updateNestedProp)({
+                node,
+                parentKey,
+                childKey,
+                value,
+                defaultValue,
+                isDefault,
+            });
+        }
+        else {
+            const attrIndex = (_b = node.attributes) === null || _b === void 0 ? void 0 : _b.findIndex((a) => {
+                if (a.type === 'JSXSpreadAttribute') {
+                    return false;
+                }
+                if (a.name.type === 'JSXNamespacedName') {
+                    return false;
+                }
+                return a.name.name === key;
+            });
+            const attr = attrIndex !== undefined && attrIndex !== -1
+                ? (_c = node.attributes) === null || _c === void 0 ? void 0 : _c[attrIndex]
+                : undefined;
+            if (attr && attr.type !== 'JSXSpreadAttribute' && attr.value) {
+                const printed = recast.print(attr.value).code;
+                // Strip JSX expression container braces, e.g. "{30}" -> "30"
+                oldValueString =
+                    printed.startsWith('{') && printed.endsWith('}')
+                        ? printed.slice(1, -1)
+                        : printed;
+            }
+            else if (attr && attr.type !== 'JSXSpreadAttribute' && !attr.value) {
+                // JSX shorthand like `loop` (no value) is implicitly `true`
+                oldValueString = 'true';
+            }
+            else if (!attr && defaultValue !== null) {
+                oldValueString = JSON.stringify(defaultValue);
+            }
+            if (isDefault) {
+                if (attr && attr.type !== 'JSXSpreadAttribute' && node.attributes) {
+                    node.attributes.splice(attrIndex, 1);
+                }
+            }
+            else {
+                const parsed = (0, update_nested_prop_1.parseValueExpression)(value);
+                const newValue = value === true ? null : b.jsxExpressionContainer(parsed);
+                if (!attr || attr.type === 'JSXSpreadAttribute') {
+                    const newAttr = b.jsxAttribute(b.jsxIdentifier(key), newValue);
+                    if (!node.attributes) {
+                        node.attributes = [];
+                    }
+                    node.attributes.push(newAttr);
+                }
+                else {
+                    attr.value = newValue;
+                }
+            }
+        }
+        oldValueStrings.push(oldValueString);
+        if (!isNested) {
+            const fieldSchema = schema[key];
+            if (fieldSchema && fieldSchema.type === 'enum') {
+                const propsToDelete = no_react_1.NoReactInternals.findPropsToDelete({
+                    schema,
+                    key,
+                    value,
+                });
+                for (const propToDelete of propsToDelete) {
+                    removeVariantKey({ node, variantKey: propToDelete });
+                }
+            }
+        }
+    }
+    const finalAttrNames = new Set();
+    for (const a of (_e = node.attributes) !== null && _e !== void 0 ? _e : []) {
+        if (a.type === 'JSXAttribute' && a.name.type === 'JSXIdentifier') {
+            finalAttrNames.add(a.name.name);
+        }
+    }
+    const removedProps = [];
+    for (const [name, valueString] of initialAttrs) {
+        if (finalAttrNames.has(name) || updatedTopLevelKeys.has(name)) {
+            continue;
+        }
+        removedProps.push({ key: name, valueString });
+    }
+    return {
+        serialized: (0, parse_ast_1.serializeAst)(ast),
+        oldValueStrings,
+        logLine,
+        removedProps,
+    };
+};
+exports.updateSequencePropsAst = updateSequencePropsAst;
+const updateSequenceProps = async ({ input, nodePath, updates, schema, prettierConfigOverride, }) => {
+    const { serialized, oldValueStrings, logLine, removedProps } = (0, exports.updateSequencePropsAst)({
+        input,
+        nodePath,
+        updates,
+        schema,
+    });
+    const { output, formatted } = await (0, format_file_content_1.formatFileContent)({
+        input: serialized,
+        prettierConfigOverride,
+    });
+    return {
+        output,
+        oldValueStrings,
+        formatted,
+        logLine,
+        removedProps,
+    };
+};
+exports.updateSequenceProps = updateSequenceProps;

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

@@ -5,15 +5,20 @@ export type SequencePropUpdate = {
     value: unknown;
     defaultValue: unknown | null;
 };
+export type RemovedProp = {
+    key: string;
+    valueString: string;
+};
 export declare const updateSequencePropsAst: ({ input, nodePath, updates, schema, }: {
     input: string;
     nodePath: SequenceNodePath;
     updates: SequencePropUpdate[];
-    schema?: SequenceSchema | undefined;
+    schema: SequenceSchema;
 }) => {
     serialized: string;
     oldValueStrings: string[];
     logLine: number;
+    removedProps: RemovedProp[];
 };
 export declare const updateSequenceProps: ({ input, nodePath, updates, schema, prettierConfigOverride, }: {
     input: string;
@@ -26,4 +31,5 @@ export declare const updateSequenceProps: ({ input, nodePath, updates, schema, p
     oldValueStrings: string[];
     formatted: boolean;
     logLine: number;
+    removedProps: RemovedProp[];
 }>;