@remotion/studio-server 4.0.484 → 4.0.486

package/dist/codemods/split-jsx-sequence.js

@@ -0,0 +1,345 @@
+"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.splitJsxSequence = exports.getIsSplittableSequenceTag = exports.getSplitUnsupportedSequenceTagReason = void 0;
+const types_1 = require("@babel/types");
+const recast = __importStar(require("recast"));
+const delete_jsx_node_1 = require("./delete-jsx-node");
+const format_file_content_1 = require("./format-file-content");
+const parse_ast_1 = require("./parse-ast");
+const { builders: b, namedTypes } = recast.types;
+const jsxId = (name) => ({ type: 'JSXIdentifier', name });
+const numericAttribute = (name, value) => ({
+    type: 'JSXAttribute',
+    name: jsxId(name),
+    value: {
+        type: 'JSXExpressionContainer',
+        expression: value === Infinity ? b.identifier('Infinity') : b.numericLiteral(value),
+    },
+});
+const getAttributeName = (attribute) => {
+    if (attribute.type !== 'JSXAttribute' ||
+        attribute.name.type !== 'JSXIdentifier') {
+        return null;
+    }
+    return attribute.name.name;
+};
+const getStaticNumber = (attribute) => {
+    if (attribute.type !== 'JSXAttribute') {
+        return null;
+    }
+    if (!attribute.value) {
+        return null;
+    }
+    if (attribute.value.type === 'StringLiteral') {
+        const parsed = Number(attribute.value.value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    if (attribute.value.type !== 'JSXExpressionContainer') {
+        return null;
+    }
+    const { expression } = attribute.value;
+    if (expression.type === 'NumericLiteral') {
+        return expression.value;
+    }
+    if (expression.type === 'Identifier' && expression.name === 'Infinity') {
+        return Infinity;
+    }
+    return null;
+};
+const readSequenceTiming = (element) => {
+    let from = 0;
+    let durationInFrames = Infinity;
+    let trimBefore = 0;
+    let hasFrom = false;
+    let hasDurationInFrames = false;
+    let hasTrimBefore = false;
+    for (const attribute of element.openingElement.attributes) {
+        const name = getAttributeName(attribute);
+        if (!name) {
+            continue;
+        }
+        if (name !== 'from' &&
+            name !== 'durationInFrames' &&
+            name !== 'trimBefore') {
+            continue;
+        }
+        const value = getStaticNumber(attribute);
+        if (value === null) {
+            throw new Error(`Cannot split sequence with dynamic ${name}`);
+        }
+        if (name === 'from') {
+            from = value;
+            hasFrom = true;
+        }
+        if (name === 'durationInFrames') {
+            durationInFrames = value;
+            hasDurationInFrames = true;
+        }
+        if (name === 'trimBefore') {
+            trimBefore = value;
+            hasTrimBefore = true;
+        }
+    }
+    return {
+        from,
+        durationInFrames,
+        trimBefore,
+        hasFrom,
+        hasDurationInFrames,
+        hasTrimBefore,
+    };
+};
+const setNumericAttribute = ({ element, name, value, omitIfMissing, }) => {
+    const { openingElement: { attributes }, } = element;
+    const index = attributes.findIndex((attribute) => getAttributeName(attribute) === name);
+    if (value === null || (index === -1 && omitIfMissing)) {
+        if (index !== -1) {
+            attributes.splice(index, 1);
+        }
+        return;
+    }
+    const next = numericAttribute(name, value);
+    if (index === -1) {
+        attributes.push(next);
+    }
+    else {
+        attributes[index] = next;
+    }
+};
+const timingAttributeOrder = ['from', 'durationInFrames', 'trimBefore'];
+const orderTimingAttributes = (element) => {
+    const { openingElement: { attributes }, } = element;
+    const timingAttributes = new Map();
+    const otherAttributes = [];
+    let firstTimingIndex = null;
+    for (let i = 0; i < attributes.length; i++) {
+        const attribute = attributes[i];
+        const name = getAttributeName(attribute);
+        if (name && timingAttributeOrder.includes(name)) {
+            timingAttributes.set(name, attribute);
+            firstTimingIndex = firstTimingIndex === null ? i : firstTimingIndex;
+        }
+        else {
+            otherAttributes.push(attribute);
+        }
+    }
+    if (firstTimingIndex === null) {
+        return;
+    }
+    const orderedTimingAttributes = timingAttributeOrder.flatMap((name) => {
+        const attribute = timingAttributes.get(name);
+        return attribute ? [attribute] : [];
+    });
+    const insertionIndex = Math.min(firstTimingIndex, otherAttributes.length);
+    attributes.splice(0, attributes.length, ...otherAttributes.slice(0, insertionIndex), ...orderedTimingAttributes, ...otherAttributes.slice(insertionIndex));
+};
+const splittableSequenceTags = new Set([
+    'AnimatedImage',
+    'Arrow',
+    'Audio',
+    'Callout',
+    'CanvasImage',
+    'Circle',
+    'Ellipse',
+    'Gif',
+    'Heart',
+    'Html5Audio',
+    'Html5Video',
+    'HtmlInCanvas',
+    'Img',
+    'OffthreadVideo',
+    'Pie',
+    'Polygon',
+    'Rect',
+    'RemotionRiveCanvas',
+    'Sequence',
+    'Solid',
+    'Spark',
+    'Star',
+    'Starburst',
+    'Triangle',
+    'Video',
+]);
+const unsupportedSequenceTags = new Set([
+    'Series.Sequence',
+    'TransitionSeries.Overlay',
+    'TransitionSeries.Sequence',
+]);
+const jsxMemberNameToString = (name) => {
+    if (name.type === 'JSXIdentifier') {
+        return name.name;
+    }
+    return `${jsxMemberNameToString(name.object)}.${name.property.name}`;
+};
+const jsxNameToString = (name) => {
+    if (name.type === 'JSXNamespacedName') {
+        return `${name.namespace.name}:${name.name.name}`;
+    }
+    return jsxMemberNameToString(name);
+};
+const getSplitUnsupportedSequenceTagReason = (tagName) => {
+    if (tagName === 'Series.Sequence' ||
+        tagName === 'TransitionSeries.Sequence' ||
+        tagName === 'TransitionSeries.Overlay') {
+        return `<${tagName}> cannot be split from source`;
+    }
+    return null;
+};
+exports.getSplitUnsupportedSequenceTagReason = getSplitUnsupportedSequenceTagReason;
+const getIsSplittableSequenceTag = (tagName) => {
+    if (unsupportedSequenceTags.has(tagName)) {
+        return false;
+    }
+    if (tagName.startsWith('Interactive.')) {
+        return true;
+    }
+    return splittableSequenceTags.has(tagName);
+};
+exports.getIsSplittableSequenceTag = getIsSplittableSequenceTag;
+const getSplittableSequenceTagName = (element) => {
+    return jsxNameToString(element.openingElement.name);
+};
+const makeFragment = (first, second) => ({
+    type: 'JSXFragment',
+    openingFragment: { type: 'JSXOpeningFragment' },
+    closingFragment: { type: 'JSXClosingFragment' },
+    children: [first, second],
+});
+const insertAfter = (parentNode, node, clone) => {
+    if (namedTypes.JSXElement.check(parentNode) ||
+        namedTypes.JSXFragment.check(parentNode)) {
+        const idx = parentNode.children.indexOf(node);
+        if (idx !== -1) {
+            parentNode.children.splice(idx + 1, 0, clone);
+            return true;
+        }
+    }
+    if (namedTypes.ReturnStatement.check(parentNode)) {
+        const parent = parentNode;
+        if (parent.argument === node) {
+            parent.argument = makeFragment(node, clone);
+            return true;
+        }
+    }
+    if (namedTypes.ArrowFunctionExpression.check(parentNode)) {
+        const parent = parentNode;
+        if (parent.body === node) {
+            parent.body = makeFragment(node, clone);
+            return true;
+        }
+    }
+    return false;
+};
+const splitJsxSequence = async ({ input, nodePath, splitFrame, prettierConfigOverride, }) => {
+    var _a, _b;
+    var _c, _d;
+    if (!Number.isInteger(splitFrame)) {
+        throw new Error('Split frame must be an integer');
+    }
+    const ast = (0, parse_ast_1.parseAst)(input);
+    const jsxPath = (0, delete_jsx_node_1.findJsxElementPathForDeletion)(ast, nodePath);
+    if (!jsxPath) {
+        throw new Error('Could not find a JSX sequence at the specified location to split');
+    }
+    const jsxElement = jsxPath.node;
+    const tagName = getSplittableSequenceTagName(jsxElement);
+    const unsupportedReason = (0, exports.getSplitUnsupportedSequenceTagReason)(tagName);
+    if (unsupportedReason) {
+        throw new Error(unsupportedReason);
+    }
+    if (!(0, exports.getIsSplittableSequenceTag)(tagName)) {
+        throw new Error(`<${tagName}> does not support sequence timing props and cannot be split`);
+    }
+    const timing = readSequenceTiming(jsxElement);
+    const finiteEnd = timing.durationInFrames === Infinity
+        ? Infinity
+        : timing.from + timing.durationInFrames;
+    if (splitFrame <= timing.from) {
+        throw new Error('Cannot split at or before the sequence start');
+    }
+    if (splitFrame >= finiteEnd) {
+        throw new Error('Cannot split at or after the sequence end');
+    }
+    const right = (0, types_1.cloneNode)(jsxElement, true);
+    const leftDuration = splitFrame - timing.from;
+    const rightDuration = timing.durationInFrames === Infinity ? Infinity : finiteEnd - splitFrame;
+    const rightTrimBefore = timing.trimBefore + leftDuration;
+    setNumericAttribute({
+        element: jsxElement,
+        name: 'durationInFrames',
+        value: leftDuration,
+        omitIfMissing: false,
+    });
+    setNumericAttribute({
+        element: right,
+        name: 'from',
+        value: splitFrame,
+        omitIfMissing: false,
+    });
+    setNumericAttribute({
+        element: right,
+        name: 'durationInFrames',
+        value: rightDuration === Infinity ? null : rightDuration,
+        omitIfMissing: !timing.hasDurationInFrames,
+    });
+    setNumericAttribute({
+        element: right,
+        name: 'trimBefore',
+        value: rightTrimBefore === 0 ? null : rightTrimBefore,
+        omitIfMissing: !timing.hasTrimBefore && rightTrimBefore === 0,
+    });
+    orderTimingAttributes(jsxElement);
+    orderTimingAttributes(right);
+    const { parentPath } = jsxPath;
+    if (!parentPath) {
+        throw new Error('Cannot split JSX sequence with no parent');
+    }
+    if (!insertAfter(parentPath.node, jsxElement, right)) {
+        jsxPath.replace(makeFragment(jsxElement, right));
+    }
+    const finalFile = (0, parse_ast_1.serializeAst)(ast);
+    const { output, formatted } = await (0, format_file_content_1.formatFileContent)({
+        input: finalFile,
+        prettierConfigOverride,
+    });
+    return {
+        output,
+        formatted,
+        nodeLabel: (0, delete_jsx_node_1.getJsxElementTagLabel)(jsxElement),
+        logLine: (_d = (_c = (_a = jsxElement.openingElement.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _c !== void 0 ? _c : (_b = jsxElement.loc) === null || _b === void 0 ? void 0 : _b.start.line) !== null && _d !== void 0 ? _d : 1,
+    };
+};
+exports.splitJsxSequence = splitJsxSequence;

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

@@ -1,8 +1,10 @@
-import type { SequenceNodePath, InteractivitySchema } from 'remotion';
+import type { GoogleFontSourceEdit } from '@remotion/studio-shared';
+import type { InteractivitySchema, SequenceNodePath } from 'remotion';
 export type SequencePropUpdate = {
     key: string;
     value: unknown;
     defaultValue: unknown | null;
+    googleFont?: GoogleFontSourceEdit | null;
 };
 export type RemovedProp = {
     key: string;