@remotion/studio-server 4.0.490 → 4.0.491

package/dist/better-opn/index.d.ts

@@ -1,4 +1,8 @@
 export declare const getChromiumBrowsersToTry: (processes: string) => ("Arc" | "Brave Browser" | "Chromium" | "Google Chrome" | "Google Chrome Canary" | "Microsoft Edge" | "Vivaldi")[];
+export declare const getFocusBrowserTabAppleScript: (chromiumBrowser: "Arc" | "Brave Browser" | "Chromium" | "Google Chrome" | "Google Chrome Canary" | "Microsoft Edge" | "Vivaldi") => string;
+export declare const focusBrowserTab: ({ url }: {
+    url: string;
+}) => Promise<boolean>;
 export declare const openBrowser: ({ url, browserFlag, browserArgs, }: {
     url: string;
     browserFlag: string | undefined;

package/dist/better-opn/index.js

@@ -1,7 +1,7 @@
 "use strict";
 // Copied from https://github.com/michaellzc/better-opn#readme
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.openBrowser = exports.getChromiumBrowsersToTry = void 0;
+exports.openBrowser = exports.focusBrowserTab = exports.getFocusBrowserTabAppleScript = exports.getChromiumBrowsersToTry = void 0;
 const node_child_process_1 = require("node:child_process");
 const open = require("open");
 const supportedChromiumBrowsers = [
@@ -21,6 +21,69 @@ const getChromiumBrowsersToTry = (processes) => {
     return supportedChromiumBrowsers.filter((browser) => processNames.has(browser));
 };
 exports.getChromiumBrowsersToTry = getChromiumBrowsersToTry;
+const CHILD_PROCESS_TIMEOUT_IN_MILLISECONDS = 10000;
+const getRunningChromiumBrowsers = async () => {
+    const processes = await new Promise((resolve, reject) => {
+        (0, node_child_process_1.exec)('ps -cax -o comm=', { timeout: CHILD_PROCESS_TIMEOUT_IN_MILLISECONDS }, (err, stdout) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+    return (0, exports.getChromiumBrowsersToTry)(processes);
+};
+const runAppleScript = ({ appleScript, args, }) => {
+    return new Promise((resolve, reject) => {
+        const proc = (0, node_child_process_1.spawn)('osascript', ['-', ...args]);
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let settled = false;
+        const timeout = setTimeout(() => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            proc.kill();
+            reject(new Error('osascript timed out'));
+        }, CHILD_PROCESS_TIMEOUT_IN_MILLISECONDS);
+        const rejectOnce = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            proc.kill();
+            reject(error);
+        };
+        proc.stdout.on('data', (chunk) => stdoutChunks.push(chunk));
+        proc.stderr.on('data', (chunk) => stderrChunks.push(chunk));
+        proc.stdin.on('error', rejectOnce);
+        proc.on('error', rejectOnce);
+        proc.on('close', (code) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            const stdout = Buffer.concat(stdoutChunks).toString('utf8');
+            if (code === 0) {
+                resolve(stdout);
+                return;
+            }
+            const stderr = Buffer.concat(stderrChunks).toString('utf8').trim();
+            reject(new Error(stderr || `osascript exited with code ${code}`));
+        });
+        proc.stdin.end(appleScript);
+    });
+};
+const isAppleScriptPermissionError = (error) => {
+    const message = error.message.toLowerCase();
+    return (message.includes('not authorised to send apple events') ||
+        message.includes('not authorized to send apple events'));
+};
 const normalizeURLToMatch = (target) => {
     // We may encounter URL parse error but want to fallback to default behavior
     try {
@@ -33,6 +96,87 @@ const normalizeURLToMatch = (target) => {
         return target;
     }
 };
+const getFocusBrowserTabAppleScript = (chromiumBrowser) => {
+    return `
+property targetTabIndex: -1
+property targetWindow: null
+property theProgram: "${chromiumBrowser}"
+
+on run argv
+  set targetURL to item 1 of argv
+
+  using terms from application "Google Chrome"
+    tell application theProgram
+      set found to my lookupTabWithUrl(targetURL)
+      if not found then
+        return false
+      end if
+
+      set targetWindow's active tab index to targetTabIndex
+      set index of targetWindow to 1
+      activate
+      return true
+    end tell
+  end using terms from
+end run
+
+on lookupTabWithUrl(lookupUrl)
+  using terms from application "Google Chrome"
+    tell application theProgram
+      set found to false
+      repeat with theWindow in every window
+        set theTabIndex to 0
+        repeat with theTab in every tab of theWindow
+          set theTabIndex to theTabIndex + 1
+          if (theTab's URL as string) is lookupUrl then
+            set targetTabIndex to theTabIndex
+            set targetWindow to theWindow
+            set found to true
+            exit repeat
+          end if
+        end repeat
+
+        if found then
+          exit repeat
+        end if
+      end repeat
+    end tell
+  end using terms from
+  return found
+end lookupTabWithUrl
+`.trim();
+};
+exports.getFocusBrowserTabAppleScript = getFocusBrowserTabAppleScript;
+const focusBrowserTab = async ({ url }) => {
+    if (process.platform !== 'darwin') {
+        return false;
+    }
+    let browsersToTry;
+    try {
+        browsersToTry = await getRunningChromiumBrowsers();
+    }
+    catch (_a) {
+        return false;
+    }
+    for (const chromiumBrowser of browsersToTry) {
+        try {
+            const result = await runAppleScript({
+                appleScript: (0, exports.getFocusBrowserTabAppleScript)(chromiumBrowser),
+                args: [url],
+            });
+            if (result.trim() === 'true') {
+                return true;
+            }
+        }
+        catch (error) {
+            if (isAppleScriptPermissionError(error)) {
+                return false;
+            }
+        }
+    }
+    return false;
+};
+exports.focusBrowserTab = focusBrowserTab;
 // Copy from
 // https://github.com/facebook/create-react-app/blob/master/packages/react-dev-utils/openBrowser.js#L64
 const startBrowserProcess = async ({ browser, url, args, }) => {
@@ -43,17 +187,7 @@ const startBrowserProcess = async ({ browser, url, args, }) => {
     if (shouldTryOpenChromiumWithAppleScript) {
         let appleScriptDenied = false;
         // Will use the first open browser found from list
-        const processes = await new Promise((resolve, reject) => {
-            (0, node_child_process_1.exec)('ps -cax -o comm=', (err, stdout) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(stdout);
-                }
-            });
-        });
-        const browsersToTry = (0, exports.getChromiumBrowsersToTry)(processes);
+        const browsersToTry = await getRunningChromiumBrowsers();
         for (const chromiumBrowser of browsersToTry) {
             if (appleScriptDenied) {
                 continue;
@@ -74,8 +208,8 @@ const startBrowserProcess = async ({ browser, url, args, }) => {
   property theProgram: "${chromiumBrowser}"
   
   on run argv
-    set theURL to "${encodeURI(url)}"
-    set matchURL to "${encodeURI(normalizeURLToMatch(url))}"
+    set theURL to item 1 of argv
+    set matchURL to item 2 of argv
     
     using terms from application "Google Chrome"
       tell application theProgram
@@ -151,27 +285,14 @@ const startBrowserProcess = async ({ browser, url, args, }) => {
     return found
   end lookupTabWithUrl
 `.trim();
-                await new Promise((resolve, reject) => {
-                    const proc = (0, node_child_process_1.exec)(`osascript -`, (error) => {
-                        if (error) {
-                            reject(error);
-                        }
-                        else {
-                            // Ignore errors.
-                            // It it breaks, it will fallback to `opn` anyway
-                            resolve();
-                        }
-                    });
-                    proc.stdin.write(appleScript);
-                    proc.stdin.end();
+                await runAppleScript({
+                    appleScript,
+                    args: [encodeURI(url), encodeURI(normalizeURLToMatch(url))],
                 });
                 return Promise.resolve(true);
             }
             catch (error) {
-                const appleScriptError = error.message;
-                if (appleScriptError
-                    .toLowerCase()
-                    .includes('not authorised to send apple events')) {
+                if (isAppleScriptPermissionError(error)) {
                     appleScriptDenied = true;
                 }
                 // Ignore errors.

package/dist/codemods/paste-effects.d.ts

@@ -1,11 +1,12 @@
 import type { EffectClipboardPasteType, EffectClipboardSnapshot } from '@remotion/studio-shared';
 import type { SequenceNodePath } from 'remotion';
-export declare const pasteEffects: ({ input, targetSequenceNodePath, type, effects, prettierConfigOverride, }: {
+export declare const pasteEffects: ({ input, targetSequenceNodePath, type, effects, insertAtIndices, prettierConfigOverride, }: {
     readonly input: string;
     readonly targetFileName: string;
     readonly targetSequenceNodePath: SequenceNodePath;
     readonly type: EffectClipboardPasteType;
     readonly effects: EffectClipboardSnapshot[];
+    readonly insertAtIndices: number[] | null;
     readonly prettierConfigOverride?: Record<string, unknown> | null | undefined;
 }) => Promise<{
     readonly output: string;

package/dist/codemods/paste-effects.js

@@ -92,7 +92,7 @@ const removeEffectsAttr = (attributes, attr) => {
         attributes.splice(index, 1);
     }
 };
-const pasteEffects = async ({ input, targetSequenceNodePath, type, effects, prettierConfigOverride, }) => {
+const pasteEffects = async ({ input, targetSequenceNodePath, type, effects, insertAtIndices, prettierConfigOverride, }) => {
     var _a;
     var _b, _c, _d;
     const ast = (0, parse_ast_1.parseAst)(input);
@@ -115,6 +115,14 @@ const pasteEffects = async ({ input, targetSequenceNodePath, type, effects, pret
     const effectCalls = effects.map((effect) => makeEffectCall({ ast, effect, remotionLocalNames }));
     const effectLabels = effects.map((effect) => `${effect.callee}()`);
     const existingAttr = (0, update_effect_props_1.findEffectsAttr)((_c = targetJsx.attributes) !== null && _c !== void 0 ? _c : []);
+    if (insertAtIndices !== null) {
+        if (type !== 'effects-additive' ||
+            insertAtIndices.length !== effectCalls.length ||
+            new Set(insertAtIndices).size !== insertAtIndices.length ||
+            insertAtIndices.some((index) => !Number.isInteger(index) || index < 0)) {
+            throw new Error('Cannot paste effects: invalid insertion indices');
+        }
+    }
     if (type === 'effects-replacing') {
         if (existingAttr) {
             removeEffectsAttr(targetJsx.attributes, existingAttr);
@@ -123,14 +131,33 @@ const pasteEffects = async ({ input, targetSequenceNodePath, type, effects, pret
             targetJsx.attributes.push(makeEffectsAttr(makeEffectsArray(effectCalls)));
         }
     }
-    else if (existingAttr) {
-        getEffectsArray(existingAttr).elements.push(...effectCalls);
+    else if (effectCalls.length === 0) {
+        throw new Error('Cannot paste effects: no effects were copied');
     }
-    else if (effectCalls.length > 0) {
-        targetJsx.attributes.push(makeEffectsAttr(makeEffectsArray(effectCalls)));
+    else if (insertAtIndices === null) {
+        if (existingAttr) {
+            getEffectsArray(existingAttr).elements.push(...effectCalls);
+        }
+        else {
+            targetJsx.attributes.push(makeEffectsAttr(makeEffectsArray(effectCalls)));
+        }
     }
     else {
-        throw new Error('Cannot paste effects: no effects were copied');
+        const elements = existingAttr
+            ? getEffectsArray(existingAttr).elements
+            : [];
+        const indexedCalls = effectCalls
+            .map((effect, index) => ({
+            effect,
+            index: insertAtIndices[index],
+        }))
+            .sort((left, right) => left.index - right.index);
+        for (const indexedCall of indexedCalls) {
+            elements.splice(Math.min(indexedCall.index, elements.length), 0, indexedCall.effect);
+        }
+        if (!existingAttr) {
+            targetJsx.attributes.push(makeEffectsAttr(b.arrayExpression(elements)));
+        }
     }
     const finalFile = (0, parse_ast_1.serializeAst)(ast);
     const { output, formatted } = await (0, format_file_content_1.formatFileContent)({

package/dist/codemods/update-keyframes/update-keyframes.d.ts

@@ -1,5 +1,5 @@
 import { type KeyframeInterpolationFunction } from '@remotion/studio-shared';
-import type { CanUpdateSequencePropStatus, ExtrapolateType, InteractivitySchema, InterpolateOutputOption, SequenceNodePath } from 'remotion';
+import type { CanUpdateSequencePropStatus, ExtrapolateType, InteractivitySchema, InterpolateOutputOption, SequenceNodePath, VideoConfigValues } from 'remotion';
 type KeyframeEasing = Extract<CanUpdateSequencePropStatus, {
     status: 'keyframed';
 }>['easing'][number];
@@ -42,11 +42,12 @@ export type IntroducedKeyframeIdentifiers = {
     needsFrameHook: boolean;
     needsEasingImport: boolean;
 };
-export declare const updateSequenceKeyframesAst: ({ input, nodePath, updates, schema, }: {
+export declare const updateSequenceKeyframesAst: ({ input, nodePath, updates, schema, videoConfigValues, }: {
     input: string;
     nodePath: SequenceNodePath;
     updates: SequenceKeyframeUpdate[];
     schema?: InteractivitySchema | undefined;
+    videoConfigValues: VideoConfigValues | null;
 }) => {
     serialized: string;
     oldValueStrings: string[];
@@ -54,12 +55,13 @@ export declare const updateSequenceKeyframesAst: ({ input, nodePath, updates, sc
     logLine: number;
     updatedNodePath: SequenceNodePath;
 };
-export declare const updateSequenceKeyframes: ({ input, nodePath, updates, schema, prettierConfigOverride, }: {
+export declare const updateSequenceKeyframes: ({ input, nodePath, updates, schema, prettierConfigOverride, videoConfigValues, }: {
     input: string;
     nodePath: SequenceNodePath;
     updates: SequenceKeyframeUpdate[];
     schema?: InteractivitySchema | undefined;
     prettierConfigOverride?: Record<string, unknown> | null | undefined;
+    videoConfigValues: VideoConfigValues | null;
 }) => Promise<{
     output: string;
     formatted: boolean;
@@ -68,12 +70,13 @@ export declare const updateSequenceKeyframes: ({ input, nodePath, updates, schem
     logLine: number;
     updatedNodePath: SequenceNodePath;
 }>;
-export declare const updateEffectKeyframesAst: ({ input, sequenceNodePath, effectIndex, updates, schema, }: {
+export declare const updateEffectKeyframesAst: ({ input, sequenceNodePath, effectIndex, updates, schema, videoConfigValues, }: {
     input: string;
     sequenceNodePath: SequenceNodePath;
     effectIndex: number;
     updates: EffectKeyframeUpdate[];
     schema?: InteractivitySchema | undefined;
+    videoConfigValues: VideoConfigValues | null;
 }) => {
     serialized: string;
     oldValueStrings: string[];
@@ -82,13 +85,14 @@ export declare const updateEffectKeyframesAst: ({ input, sequenceNodePath, effec
     effectCallee: string;
     updatedSequenceNodePath: SequenceNodePath;
 };
-export declare const updateEffectKeyframes: ({ input, sequenceNodePath, effectIndex, updates, schema, prettierConfigOverride, }: {
+export declare const updateEffectKeyframes: ({ input, sequenceNodePath, effectIndex, updates, schema, prettierConfigOverride, videoConfigValues, }: {
     input: string;
     sequenceNodePath: SequenceNodePath;
     effectIndex: number;
     updates: EffectKeyframeUpdate[];
     schema?: InteractivitySchema | undefined;
     prettierConfigOverride?: Record<string, unknown> | null | undefined;
+    videoConfigValues: VideoConfigValues | null;
 }) => Promise<{
     output: string;
     formatted: boolean;