@remotion/studio-server 4.0.91

package/.eslintrc

@@ -0,0 +1,13 @@
+{
+	"extends": "@jonny",
+	"rules": {
+		"no-console": "error",
+		"no-restricted-imports": [
+			"error",
+			{
+				"patterns": ["@remotion/*/src/*", "remotion/src/*"]
+			}
+		],
+		"@typescript-eslint/no-use-before-define": "off"
+	}
+}

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @remotion/studio-server@4.0.90 build /Users/jonathanburger/remotion/packages/studio-server
+> tsc -d
+

package/LICENSE.md

@@ -0,0 +1,45 @@
+# Remotion License
+
+Depending on the type of your legal entity, you are granted permission to use Remotion for your project. Individuals and small companies are allowed to use Remotion to create videos for free (even commercial), while a company license is required for for-profit organizations of a certain size. This two-tier system was designed to ensure funding for this project while still allowing the source code to be available and the program to be free for most. Read below for the exact terms of use.
+
+- [Free license](#free-license)
+- [Company license](#company-license)
+
+## Free license
+
+Copyright © 2023 [Remotion](https://www.remotion.dev)
+
+### Eligibility
+
+You are eligible to use Remotion for free if you are:
+
+- an individual
+- a for-profit organization with up to 3 employees
+- a non-profit or not-for-profit organization
+- evaluating whether Remotion is a good fit, and are not yet using it in a commercial way
+
+### Allowed use cases
+
+Permission is hereby granted, free of charge, to any person eligible for the "Free license", to use the software non-commercially or commercially for the purpose of creating videos and images and to modify the software to their own liking, for the purpose of fulfilling their custom use case or to contribute bug fixes or improvements back to Remotion.
+
+### Disallowed use cases
+
+It is not allowed to copy or modify Remotion code for the purpose of selling, renting, licensing, relicensing, or sublicensing your own derivate of Remotion.
+
+### Warranty notice
+
+The software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. In no event shall the author or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the software.
+
+### Support
+
+Support is provided on a best-we-can-do basis via GitHub Issues and Discord.
+
+## Company license
+
+You are required to obtain a company license to use Remotion if you are not within the group of entities eligible for a free license. This license will enable you to use Remotion for the allowed use cases specified in the free license, and give you access to prioritized support (read the [Support Policy](https://www.remotion.dev/docs/support)).
+
+Visit [remotion.pro](https://www.remotion.pro/license) for pricing and to buy a license.
+
+### FAQs
+
+Are you not sure whether you need a company license because of an edge case? Here are some [frequently asked questions](https://www.remotion.pro/faq).

package/README.md

@@ -0,0 +1,3 @@
+# `@remotion/studio-server`
+
+Right now the APIs in here are not meant for public consumption.

package/dist/ansi-diff.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+type Options = {
+    width?: number;
+    height?: number;
+};
+export declare class AnsiDiff {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    _buffer: string | null;
+    _out: Buffer[];
+    _lines: Line[];
+    finished: boolean;
+    constructor(opts?: Options);
+    toString(): string | null;
+    finish(): Buffer;
+    update(buffer: string | Buffer, opts?: {
+        moveTo?: [number, number];
+    }): Buffer;
+    _clearDown(y: number): void;
+    _newline(): void;
+    _write(line: Line): void;
+    _moveTo(x: number, y: number): void;
+    _push: (buf: Buffer) => void;
+}
+declare class Line {
+    y: number;
+    width: number;
+    parts: string[];
+    height: number;
+    remainder: number;
+    raw: string;
+    length: number;
+    newline: boolean;
+    constructor(str: string, y: number, nl: boolean, term: AnsiDiff);
+    diffLeft(other: Line): number;
+    diffRight(other: Line): number;
+    toBuffer(): Buffer;
+}
+export {};

package/dist/ansi-diff.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnsiDiff = void 0;
+const studio_shared_1 = require("@remotion/studio-shared");
+const CLEAR_LINE = Buffer.from([0x1b, 0x5b, 0x30, 0x4b]);
+const NEWLINE = Buffer.from('\n');
+class AnsiDiff {
+    constructor(opts) {
+        this._push = (buf) => {
+            this._out.push(buf);
+        };
+        this.x = 0;
+        this.y = 0;
+        this.width = (opts === null || opts === void 0 ? void 0 : opts.width) || Infinity;
+        this.height = (opts === null || opts === void 0 ? void 0 : opts.height) || Infinity;
+        this._buffer = null;
+        this._out = [];
+        this._lines = [];
+        this.finished = false;
+    }
+    toString() {
+        return this._buffer;
+    }
+    finish() {
+        this.finished = true;
+        if (this._out.length === 0) {
+            return Buffer.from('');
+        }
+        if (!this._out[this._out.length - 1].toString().endsWith('\n')) {
+            return NEWLINE;
+        }
+        return Buffer.from('');
+    }
+    update(buffer, opts) {
+        if (this.finished) {
+            return Buffer.from('');
+        }
+        this._buffer = Buffer.isBuffer(buffer) ? buffer.toString() : buffer;
+        const other = this._buffer;
+        const oldLines = this._lines;
+        const lines = split(other, this);
+        this._lines = lines;
+        this._out = [];
+        const min = Math.min(lines.length, oldLines.length);
+        let i = 0;
+        let a;
+        let b;
+        let scrub = false;
+        for (; i < min; i++) {
+            a = lines[i];
+            b = oldLines[i];
+            if (same(a, b))
+                continue;
+            // if x === width there is an edgecase with inline diffing
+            // easiest solution is just not to do it then! :)
+            if (!scrub && this.x !== this.width && inlineDiff(a, b)) {
+                const left = a.diffLeft(b);
+                const right = a.diffRight(b);
+                const slice = a.raw.slice(left, right ? -right : a.length);
+                if (left + right > 4 && left + slice.length < this.width - 1) {
+                    this._moveTo(left, a.y);
+                    this._push(Buffer.from(slice));
+                    this.x += slice.length;
+                    continue;
+                }
+            }
+            this._moveTo(0, a.y);
+            this._write(a);
+            if (a.y !== b.y || a.height !== b.height)
+                scrub = true;
+            if (b.length > a.length || scrub)
+                this._push(CLEAR_LINE);
+            if (a.newline)
+                this._newline();
+        }
+        for (; i < lines.length; i++) {
+            a = lines[i];
+            this._moveTo(0, a.y);
+            this._write(a);
+            if (scrub)
+                this._push(CLEAR_LINE);
+            if (a.newline)
+                this._newline();
+        }
+        const oldLast = top(oldLines);
+        const last = top(lines);
+        if (oldLast &&
+            (!last || last.y + last.height < oldLast.y + oldLast.height)) {
+            this._clearDown(oldLast.y + oldLast.height);
+        }
+        if (opts === null || opts === void 0 ? void 0 : opts.moveTo) {
+            this._moveTo(opts.moveTo[0], opts.moveTo[1]);
+        }
+        else if (last) {
+            this._moveTo(last.remainder, last.y + last.height);
+        }
+        return Buffer.concat(this._out);
+    }
+    _clearDown(y) {
+        let { x } = this;
+        for (let i = this.y; i <= y; i++) {
+            this._moveTo(x, i);
+            this._push(CLEAR_LINE);
+            x = 0;
+        }
+    }
+    _newline() {
+        this._push(NEWLINE);
+        this.x = 0;
+        this.y++;
+    }
+    _write(line) {
+        this._out.push(line.toBuffer());
+        this.x = line.remainder;
+        this.y += line.height;
+    }
+    _moveTo(x, y) {
+        const dx = x - this.x;
+        const dy = y - this.y;
+        if (dx > 0)
+            this._push(moveRight(dx));
+        else if (dx < 0)
+            this._push(moveLeft(-dx));
+        if (dy > 0)
+            this._push(moveDown(dy));
+        else if (dy < 0)
+            this._push(moveUp(-dy));
+        this.x = x;
+        this.y = y;
+    }
+}
+exports.AnsiDiff = AnsiDiff;
+function same(a, b) {
+    return (a.y === b.y &&
+        a.width === b.width &&
+        a.raw === b.raw &&
+        a.newline === b.newline);
+}
+function top(list) {
+    return list.length ? list[list.length - 1] : null;
+}
+class Line {
+    constructor(str, y, nl, term) {
+        this.y = y;
+        this.width = term.width;
+        this.parts = (0, studio_shared_1.splitAnsi)(str);
+        this.length = length(this.parts);
+        this.raw = str;
+        this.newline = nl;
+        this.height = Math.floor(this.length / term.width);
+        this.remainder = this.length - (this.height && this.height * term.width);
+        if (this.height && !this.remainder) {
+            this.height--;
+            this.remainder = this.width;
+        }
+    }
+    diffLeft(other) {
+        let left = 0;
+        for (; left < this.length; left++) {
+            if (this.raw[left] !== other.raw[left])
+                return left;
+        }
+        return left;
+    }
+    diffRight(other) {
+        let right = 0;
+        for (; right < this.length; right++) {
+            const r = this.length - right - 1;
+            if (this.raw[r] !== other.raw[r])
+                return right;
+        }
+        return right;
+    }
+    toBuffer() {
+        return Buffer.from(this.raw);
+    }
+}
+function inlineDiff(a, b) {
+    return (a.length === b.length &&
+        a.parts.length === 1 &&
+        b.parts.length === 1 &&
+        a.y === b.y &&
+        a.newline &&
+        b.newline &&
+        a.width === b.width);
+}
+function split(str, term) {
+    let y = 0;
+    const lines = str.split('\n');
+    const wrapped = [];
+    let line;
+    for (let i = 0; i < lines.length; i++) {
+        line = new Line(lines[i], y, i < lines.length - 1, term);
+        y += line.height + (line.newline ? 1 : 0);
+        wrapped.push(line);
+    }
+    return wrapped;
+}
+function moveUp(n) {
+    return Buffer.from('1b5b' + toHex(n) + '41', 'hex');
+}
+function moveDown(n) {
+    return Buffer.from('1b5b' + toHex(n) + '42', 'hex');
+}
+function moveRight(n) {
+    return Buffer.from('1b5b' + toHex(n) + '43', 'hex');
+}
+function moveLeft(n) {
+    return Buffer.from('1b5b' + toHex(n) + '44', 'hex');
+}
+function length(parts) {
+    let len = 0;
+    for (let i = 0; i < parts.length; i += 2) {
+        len += parts[i].length;
+    }
+    return len;
+}
+function toHex(n) {
+    return Buffer.from(String(n)).toString('hex');
+}

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

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+export declare const openBrowser: ({ url, browserFlag, browserArgs, }: {
+    url: string;
+    browserFlag: string | undefined;
+    browserArgs: string | undefined;
+}) => Promise<boolean | import("child_process").ChildProcess>;

package/dist/better-opn/index.js

@@ -0,0 +1,202 @@
+"use strict";
+// Copied from https://github.com/michaellzc/better-opn#readme
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openBrowser = void 0;
+const node_child_process_1 = require("node:child_process");
+const open = require("open");
+const normalizeURLToMatch = (target) => {
+    // We may encounter URL parse error but want to fallback to default behavior
+    try {
+        // Url module is deprecated on newer version of NodeJS, only use it when URL class is not supported (like Node 8)
+        const URL = typeof global.URL === 'undefined' ? require('url').URL : global.URL;
+        const url = new URL(target);
+        return url.origin;
+    }
+    catch (_a) {
+        return target;
+    }
+};
+// Copy from
+// https://github.com/facebook/create-react-app/blob/master/packages/react-dev-utils/openBrowser.js#L64
+const startBrowserProcess = async ({ browser, url, args, }) => {
+    const tryNewInstance = args.length > 0;
+    const shouldTryOpenChromiumWithAppleScript = process.platform === 'darwin' &&
+        !tryNewInstance &&
+        (typeof browser !== 'string' ||
+            browser === 'google chrome' ||
+            browser === 'chrome');
+    if (shouldTryOpenChromiumWithAppleScript) {
+        let appleScriptDenied = false;
+        // Will use the first open browser found from list
+        const supportedChromiumBrowsers = [
+            'Google Chrome',
+            'Google Chrome Canary',
+            'Microsoft Edge',
+            'Brave Browser',
+            'Vivaldi',
+            'Chromium',
+            'Arc',
+        ];
+        const processes = await new Promise((resolve, reject) => {
+            (0, node_child_process_1.exec)('ps cax', (err, stdout) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(stdout);
+                }
+            });
+        });
+        const browsersToTry = supportedChromiumBrowsers.filter((b) => processes.includes(b));
+        for (const chromiumBrowser of browsersToTry) {
+            if (appleScriptDenied) {
+                continue;
+            }
+            try {
+                // Try our best to reuse existing tab
+                // on OSX Chromium-based browser with AppleScript
+                const appleScript = `
+(*
+  Copyright (c) 2015-present, Facebook, Inc.
+  This source code is licensed under the MIT license found in the
+  LICENSE file in the root directory of this source tree.
+  *)
+  
+  property targetTab: null
+  property targetTabIndex: -1
+  property targetWindow: null
+  property theProgram: "${chromiumBrowser}"
+  
+  on run argv
+    set theURL to "${encodeURI(url)}"
+    set matchURL to "${process.env.OPEN_MATCH_HOST_ONLY === 'true'
+                    ? encodeURI(normalizeURLToMatch(url))
+                    : encodeURI(url)}"
+    
+    using terms from application "Google Chrome"
+      tell application theProgram
+  
+        if (count every window) = 0 then
+          make new window
+        end if
+  
+        -- 1: Looking for tab running debugger
+        -- then, Reload debugging tab if found
+        -- then return
+        set found to my lookupTabWithUrl(matchURL)
+        if found then
+          set targetWindow's active tab index to targetTabIndex
+          tell targetTab to reload
+          tell targetWindow to activate
+          set index of targetWindow to 1
+          return
+        end if
+  
+        -- 2: Looking for Empty tab
+        -- In case debugging tab was not found
+        -- We try to find an empty tab instead
+        set found to my lookupTabWithUrl("chrome://newtab/")
+        if found then
+          set targetWindow's active tab index to targetTabIndex
+          set URL of targetTab to theURL
+          tell targetWindow to activate
+          return
+        end if
+  
+        -- 3: Create new tab
+        -- both debugging and empty tab were not found
+        -- make a new tab with url
+        tell window 1
+          activate
+          make new tab with properties {URL:theURL}
+        end tell
+      end tell
+    end using terms from
+  end run
+  
+  -- Function:
+  -- Lookup tab with given url
+  -- if found, store tab, index, and window in properties
+  -- (properties were declared on top of file)
+  on lookupTabWithUrl(lookupUrl)
+    using terms from application "Google Chrome"
+      tell application theProgram
+        -- Find a tab with the given url
+        set found to false
+        set theTabIndex to -1
+        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) contains lookupUrl then
+              -- assign tab, tab index, and window to properties
+              set targetTab to theTab
+              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();
+                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();
+                });
+                return Promise.resolve(true);
+            }
+            catch (error) {
+                const appleScriptError = error.message;
+                if (appleScriptError
+                    .toLowerCase()
+                    .includes('not authorised to send apple events')) {
+                    appleScriptDenied = true;
+                }
+                // Ignore errors.
+                // It it breaks, it will fallback to `opn` anyway
+            }
+        }
+    }
+    // Fallback to opn
+    // (It will always open new tab)
+    return open(url, {
+        ...(browser ? { app: { name: browser, arguments: args } } : {}),
+        newInstance: tryNewInstance,
+        wait: false,
+    });
+};
+const getBrowserArgs = (browserArgs) => {
+    if (browserArgs) {
+        return browserArgs.split(' ');
+    }
+    if (process.env.BROWSER_ARGS) {
+        return process.env.BROWSER_ARGS.split(' ');
+    }
+    return [];
+};
+const openBrowser = ({ url, browserFlag, browserArgs, }) => {
+    return startBrowserProcess({
+        browser: browserFlag !== null && browserFlag !== void 0 ? browserFlag : process.env.BROWSER,
+        url,
+        args: getBrowserArgs(browserArgs),
+    });
+};
+exports.openBrowser = openBrowser;

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

@@ -0,0 +1,7 @@
+import type { EnumPath } from '@remotion/studio-shared';
+export declare const updateDefaultProps: ({ input, compositionId, newDefaultProps, enumPaths, }: {
+    input: string;
+    compositionId: string;
+    newDefaultProps: Record<string, unknown>;
+    enumPaths: EnumPath[];
+}) => Promise<string>;

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

@@ -0,0 +1,137 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateDefaultProps = void 0;
+const studio_shared_1 = require("@remotion/studio-shared");
+const findStarter = ({ input, compositionId, }) => {
+    const format1 = input.indexOf(`id="${compositionId}"`);
+    if (format1 > -1) {
+        return format1;
+    }
+    const format2 = input.indexOf(`id='${compositionId}'`);
+    if (format2 > -1) {
+        return format2;
+    }
+    const format3 = input.indexOf(`id={'${compositionId}'}`);
+    if (format3 > -1) {
+        return format3;
+    }
+    const format4 = input.indexOf(`id={"${compositionId}"}`);
+    if (format4 > -1) {
+        return format4;
+    }
+    const format5 = input.indexOf(`id={\`${compositionId}\``);
+    if (format5 > -1) {
+        return format5;
+    }
+    throw new Error(`Could not find composition ID ${compositionId} in file`);
+};
+const findEndPosition = (input, currentPosition) => {
+    const asConstVersion = input
+        .slice(currentPosition + 1)
+        .search(/as\sconst[ \t\n\r]+\}/);
+    if (asConstVersion !== -1) {
+        const nextEnd = input.indexOf('}', asConstVersion + currentPosition + 1);
+        return nextEnd - 1;
+    }
+    // When updating e.g. `defaultProps={{union: {type: 'car' as const, color: ''}}}`
+    const nextTriple = input.indexOf('}}}', currentPosition + 1);
+    if (nextTriple !== -1) {
+        return nextTriple + 1;
+    }
+    const nextLinux = input.indexOf('}}\n', currentPosition + 1);
+    const nextWindows = input.indexOf('}}\r', currentPosition + 1);
+    if (nextLinux !== -1) {
+        return nextLinux;
+    }
+    if (nextWindows !== -1) {
+        return nextWindows;
+    }
+    throw new Error('Could not find end of defaultProps');
+};
+const findEnder = (input, position, maxPosition, compositionId) => {
+    let currentPosition = position;
+    while (currentPosition < maxPosition) {
+        const next = findEndPosition(input, currentPosition);
+        currentPosition = next;
+        const nextChar = input[next + 1];
+        if (nextChar === ',') {
+            continue;
+        }
+        return [position, currentPosition + 1];
+    }
+    throw new Error(`No \`defaultProps\` prop found in the <Composition/> tag with the ID "${compositionId}".`);
+};
+const findTerminators = (input, position) => {
+    const nextComposition = input.indexOf('<Composition', position);
+    if (nextComposition > -1) {
+        return nextComposition;
+    }
+    const nextStill = input.indexOf('<Still', position);
+    if (nextStill > -1) {
+        return nextStill;
+    }
+    return Infinity;
+};
+const updateDefaultProps = async ({ input, compositionId, newDefaultProps, enumPaths, }) => {
+    const starter = findStarter({ input, compositionId });
+    const START_TOKEN = 'defaultProps={';
+    const start = input.indexOf(START_TOKEN, starter);
+    if (start === -1) {
+        throw new Error(`No \`defaultProps\` prop found in the <Composition/> tag with the ID "${compositionId}".`);
+    }
+    const maxEnd = findTerminators(input, starter);
+    const [startPos, endPos] = findEnder(input, start + START_TOKEN.length, maxEnd, compositionId);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-imports
+    let prettier = null;
+    try {
+        prettier = await Promise.resolve().then(() => __importStar(require('prettier')));
+    }
+    catch (err) {
+        throw new Error('Prettier cannot be found in the current project.');
+    }
+    const { format, resolveConfig, resolveConfigFile } = prettier;
+    const newFile = input.substring(0, startPos) +
+        (0, studio_shared_1.stringifyDefaultProps)({ props: newDefaultProps, enumPaths }) +
+        input.substring(endPos);
+    const configFilePath = await resolveConfigFile();
+    if (!configFilePath) {
+        throw new Error('The Prettier config file was not found');
+    }
+    const prettierConfig = await resolveConfig(configFilePath);
+    if (!prettierConfig) {
+        throw new Error(`The Prettier config at ${configFilePath} could not be read`);
+    }
+    const prettified = format(newFile, {
+        ...prettierConfig,
+        rangeStart: startPos,
+        rangeEnd: endPos,
+        filepath: 'test.tsx',
+        plugins: [],
+        endOfLine: 'auto',
+    });
+    return prettified;
+};
+exports.updateDefaultProps = updateDefaultProps;