@remotion/cli 4.0.0-webhook.27 → 4.1.0-alpha1

package/dist/chalk/index.d.ts

@@ -1,58 +1,49 @@
-declare type Style = {
-    codes: [number, number];
-    name: string;
-    wrap?: (input: string, newline: boolean) => string;
-};
-declare type Method = (str: string) => string;
-declare type Colors = {
+export declare const chalk: {
     enabled: boolean;
     visible: boolean;
-    styles: Record<string, Style>;
+    styles: Record<string, {
+        codes: [number, number];
+        name: string;
+        wrap?: ((input: string, newline: boolean) => string) | undefined;
+    }>;
     keys: Record<string, string[]>;
-    alias?: (name: string, col: string) => void;
-};
-declare type ColorsWithMethods = Colors & {
-    reset: Method;
-    bold: Method;
-    dim: Method;
-    italic: Method;
-    underline: Method;
-    inverse: Method;
-    hidden: Method;
-    strikethrough: Method;
-    black: Method;
-    red: Method;
-    green: Method;
-    yellow: Method;
-    blue: Method;
-    magenta: Method;
-    cyan: Method;
-    white: Method;
-    gray: Method;
-    bgBlack: Method;
-    bgRed: Method;
-    bgGreen: Method;
-    bgYellow: Method;
-    bgBlue: Method;
-    bgMagenta: Method;
-    bgCyan: Method;
-    bgWhite: Method;
-    blackBright: Method;
-    redBright: Method;
-    greenBright: Method;
-    yellowBright: Method;
-    blueBright: Method;
-    magentaBright: Method;
-    cyanBright: Method;
-    whiteBright: Method;
-    bgBlackBright: Method;
-    bgRedBright: Method;
-    bgGreenBright: Method;
-    bgYellowBright: Method;
-    bgBlueBright: Method;
-    bgMagentaBright: Method;
-    bgCyanBright: Method;
-    bgWhiteBright: Method;
+    alias?: ((name: string, col: string) => void) | undefined;
+} & {
+    reset: (str: string) => string;
+    bold: (str: string) => string;
+    dim: (str: string) => string;
+    italic: (str: string) => string;
+    underline: (str: string) => string;
+    inverse: (str: string) => string;
+    hidden: (str: string) => string;
+    strikethrough: (str: string) => string;
+    black: (str: string) => string;
+    red: (str: string) => string;
+    green: (str: string) => string;
+    yellow: (str: string) => string;
+    blue: (str: string) => string;
+    magenta: (str: string) => string;
+    white: (str: string) => string;
+    gray: (str: string) => string;
+    bgBlack: (str: string) => string;
+    bgRed: (str: string) => string;
+    bgGreen: (str: string) => string;
+    bgYellow: (str: string) => string;
+    bgBlue: (str: string) => string;
+    bgMagenta: (str: string) => string;
+    bgWhite: (str: string) => string;
+    blackBright: (str: string) => string;
+    redBright: (str: string) => string;
+    greenBright: (str: string) => string;
+    yellowBright: (str: string) => string;
+    blueBright: (str: string) => string;
+    magentaBright: (str: string) => string;
+    whiteBright: (str: string) => string;
+    bgBlackBright: (str: string) => string;
+    bgRedBright: (str: string) => string;
+    bgGreenBright: (str: string) => string;
+    bgYellowBright: (str: string) => string;
+    bgBlueBright: (str: string) => string;
+    bgMagentaBright: (str: string) => string;
+    bgWhiteBright: (str: string) => string;
 };
-export declare const chalk: ColorsWithMethods;
-export {};

package/dist/chalk/index.js

@@ -1,138 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.chalk = void 0;
-const hasColor = () => {
-    if (typeof process !== 'undefined') {
-        return process.env.FORCE_COLOR !== '0';
-    }
-    return false;
-};
-exports.chalk = (() => {
-    const colors = {
-        enabled: hasColor(),
-        visible: true,
-        styles: {},
-        keys: {},
-    };
-    const ansi = (st) => {
-        const open = `\u001b[${st.codes[0]}m`;
-        const close = `\u001b[${st.codes[1]}m`;
-        const regex = new RegExp(`\\u001b\\[${st.codes[1]}m`, 'g');
-        st.wrap = (input, newline) => {
-            if (input.includes(close))
-                input = input.replace(regex, close + open);
-            const output = open + input + close;
-            // see https://github.com/chalk/chalk/pull/92, thanks to the
-            // chalk contributors for this fix. However, we've confirmed that
-            // this issue is also present in Windows terminals
-            return newline ? output.replace(/\r*\n/g, `${close}$&${open}`) : output;
-        };
-        return st;
-    };
-    const wrap = (sty, input, newline) => {
-        var _a;
-        return (_a = sty.wrap) === null || _a === void 0 ? void 0 : _a.call(sty, input, newline);
-    };
-    const style = (input, stack) => {
-        if (input === '' || input === null || input === undefined)
-            return '';
-        if (colors.enabled === false)
-            return input;
-        if (colors.visible === false)
-            return '';
-        let str = String(input);
-        const nl = str.includes('\n');
-        let n = stack.length;
-        while (n-- > 0)
-            str = wrap(colors.styles[stack[n]], str, nl);
-        return str;
-    };
-    const define = (name, codes, type) => {
-        colors.styles[name] = ansi({ name, codes });
-        const keys = colors.keys[type] || (colors.keys[type] = []);
-        keys.push(name);
-        Reflect.defineProperty(colors, name, {
-            configurable: true,
-            enumerable: true,
-            set(value) {
-                var _a;
-                (_a = colors.alias) === null || _a === void 0 ? void 0 : _a.call(colors, name, value);
-            },
-            get() {
-                const color = (input) => style(input, color.stack);
-                Reflect.setPrototypeOf(color, colors);
-                color.stack = this.stack ? this.stack.concat(name) : [name];
-                return color;
-            },
-        });
-    };
-    define('reset', [0, 0], 'modifier');
-    define('bold', [1, 22], 'modifier');
-    define('dim', [2, 22], 'modifier');
-    define('italic', [3, 23], 'modifier');
-    define('underline', [4, 24], 'modifier');
-    define('inverse', [7, 27], 'modifier');
-    define('hidden', [8, 28], 'modifier');
-    define('strikethrough', [9, 29], 'modifier');
-    define('black', [30, 39], 'color');
-    define('red', [31, 39], 'color');
-    define('green', [32, 39], 'color');
-    define('yellow', [33, 39], 'color');
-    define('blue', [34, 39], 'color');
-    define('magenta', [35, 39], 'color');
-    define('cyan', [36, 39], 'color');
-    define('white', [37, 39], 'color');
-    define('gray', [90, 39], 'color');
-    define('grey', [90, 39], 'color');
-    define('bgBlack', [40, 49], 'bg');
-    define('bgRed', [41, 49], 'bg');
-    define('bgGreen', [42, 49], 'bg');
-    define('bgYellow', [43, 49], 'bg');
-    define('bgBlue', [44, 49], 'bg');
-    define('bgMagenta', [45, 49], 'bg');
-    define('bgCyan', [46, 49], 'bg');
-    define('bgWhite', [47, 49], 'bg');
-    define('blackBright', [90, 39], 'bright');
-    define('redBright', [91, 39], 'bright');
-    define('greenBright', [92, 39], 'bright');
-    define('yellowBright', [93, 39], 'bright');
-    define('blueBright', [94, 39], 'bright');
-    define('magentaBright', [95, 39], 'bright');
-    define('cyanBright', [96, 39], 'bright');
-    define('whiteBright', [97, 39], 'bright');
-    define('bgBlackBright', [100, 49], 'bgBright');
-    define('bgRedBright', [101, 49], 'bgBright');
-    define('bgGreenBright', [102, 49], 'bgBright');
-    define('bgYellowBright', [103, 49], 'bgBright');
-    define('bgBlueBright', [104, 49], 'bgBright');
-    define('bgMagentaBright', [105, 49], 'bgBright');
-    define('bgCyanBright', [106, 49], 'bgBright');
-    define('bgWhiteBright', [107, 49], 'bgBright');
-    colors.alias = (name, color) => {
-        // @ts-expect-error
-        const fn = colors[color];
-        if (typeof fn !== 'function') {
-            throw new TypeError('Expected alias to be the name of an existing color (string) or a function');
-        }
-        if (!fn.stack) {
-            Reflect.defineProperty(fn, 'name', { value: name });
-            colors.styles[name] = fn;
-            fn.stack = [name];
-        }
-        Reflect.defineProperty(colors, name, {
-            configurable: true,
-            enumerable: true,
-            set(value) {
-                var _a;
-                (_a = colors.alias) === null || _a === void 0 ? void 0 : _a.call(colors, name, value);
-            },
-            get() {
-                const col = (input) => style(input, col.stack);
-                Reflect.setPrototypeOf(col, colors);
-                col.stack = this.stack ? this.stack.concat(fn.stack) : fn.stack;
-                return col;
-            },
-        });
-    };
-    return colors;
-})();
+const renderer_1 = require("@remotion/renderer");
+exports.chalk = renderer_1.RenderInternals.chalk;

package/dist/cleanup-before-quit.d.ts

@@ -0,0 +1,3 @@
+export declare const cleanupBeforeQuit: () => void;
+export declare const registerCleanupJob: (job: () => void) => void;
+export declare const handleCtrlC: () => void;

package/dist/cleanup-before-quit.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCtrlC = exports.registerCleanupJob = exports.cleanupBeforeQuit = void 0;
+const log_1 = require("./log");
+const cleanupJobs = [];
+const cleanupBeforeQuit = () => {
+    log_1.Log.verbose('Cleaning up...');
+    const time = Date.now();
+    for (const job of cleanupJobs) {
+        job();
+    }
+    log_1.Log.verbose(`Cleanup done in ${Date.now() - time}ms`);
+};
+exports.cleanupBeforeQuit = cleanupBeforeQuit;
+const registerCleanupJob = (job) => {
+    cleanupJobs.push(job);
+};
+exports.registerCleanupJob = registerCleanupJob;
+const handleCtrlC = () => {
+    process.on('SIGINT', () => {
+        log_1.Log.info();
+        (0, exports.cleanupBeforeQuit)();
+        process.exit(0);
+    });
+};
+exports.handleCtrlC = handleCtrlC;

package/dist/cloudrun-command.d.ts

@@ -0,0 +1 @@
+export declare const cloudrunCommand: (remotionRoot: string, args: string[]) => Promise<never>;

package/dist/cloudrun-command.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloudrunCommand = void 0;
+const log_1 = require("./log");
+const get_package_manager_1 = require("./preview-server/get-package-manager");
+const update_available_1 = require("./preview-server/update-available");
+const cloudrunCommand = async (remotionRoot, args) => {
+    try {
+        const path = require.resolve('@remotion/cloudrun', {
+            paths: [remotionRoot],
+        });
+        const { CloudrunInternals } = require(path);
+        await CloudrunInternals.executeCommand(args, remotionRoot);
+        process.exit(0);
+    }
+    catch (err) {
+        const manager = (0, get_package_manager_1.getPackageManager)(remotionRoot, undefined);
+        const installCommand = manager === 'unknown' ? 'npm i' : manager.installCommand;
+        log_1.Log.error(err);
+        log_1.Log.error('Remotion CloudRun is not installed.');
+        log_1.Log.info('');
+        log_1.Log.info('You can install it using:');
+        log_1.Log.info(`${installCommand} @remotion/cloudrun@${(0, update_available_1.getRemotionVersion)()}`);
+        process.exit(1);
+    }
+};
+exports.cloudrunCommand = cloudrunCommand;

package/dist/code-frame.js

@@ -25,8 +25,12 @@ const printCodeFrame = (frame) => {
     const alignLeftAmount = Math.min(...frame.originalScriptCode.map((c) => c.content.length - c.content.trimStart().length));
     log_1.Log.info(`${frame.originalScriptCode
         .map((c) => {
-        const content = `${String(c.lineNumber).padStart(longestLineNumber, ' ')} | ${c.content.substring(alignLeftAmount)}`;
-        return c.highlight ? content : chalk_1.chalk.gray(content);
+        const left = String(c.lineNumber).padStart(longestLineNumber, ' ');
+        const right = c.content.substring(alignLeftAmount);
+        if (c.highlight) {
+            return `${left} │ ${right}`;
+        }
+        return `${chalk_1.chalk.gray(left)} │ ${chalk_1.chalk.gray(right)}`;
     })
         .join('\n')}`);
 };
@@ -40,7 +44,7 @@ const logLine = (frame) => {
         .join(' ')));
 };
 const printCodeFrameAndStack = (err) => {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     if (!err.symbolicatedStackFrames ||
         err.symbolicatedStackFrames.length === 0) {
         log_1.Log.error(err.stack);
@@ -54,16 +58,23 @@ const printCodeFrameAndStack = (err) => {
         if (frame === firstFrame) {
             continue;
         }
-        logLine(frame);
+        const isUserCode = !((_a = frame.originalFileName) === null || _a === void 0 ? void 0 : _a.includes('node_modules')) &&
+            !((_b = frame.originalFileName) === null || _b === void 0 ? void 0 : _b.startsWith('webpack/'));
+        if (isUserCode) {
+            printCodeFrame(frame);
+        }
+        else {
+            logLine(frame);
+        }
     }
     if (err.delayRenderCall) {
         log_1.Log.error();
         log_1.Log.error('🕧 The delayRender() call is located at:');
         for (const frame of err.delayRenderCall) {
-            const showCodeFrame = (!((_a = frame.originalFileName) === null || _a === void 0 ? void 0 : _a.includes('node_modules')) &&
-                !((_b = frame.originalFileName) === null || _b === void 0 ? void 0 : _b.startsWith('webpack/'))) ||
+            const showCodeFrame = (!((_c = frame.originalFileName) === null || _c === void 0 ? void 0 : _c.includes('node_modules')) &&
+                !((_d = frame.originalFileName) === null || _d === void 0 ? void 0 : _d.startsWith('webpack/'))) ||
                 frame === err.delayRenderCall[0] ||
-                ((_c = frame.originalScriptCode) === null || _c === void 0 ? void 0 : _c.map((c) => c.content).join('').includes('delayRender'));
+                ((_e = frame.originalScriptCode) === null || _e === void 0 ? void 0 : _e.map((c) => c.content).join('').includes('delayRender'));
             if (showCodeFrame) {
                 printCodeFrame(frame);
             }

package/dist/codemods/stringify-with-path.d.ts

@@ -0,0 +1,5 @@
+import type { EnumPath } from '../editor/components/RenderModal/SchemaEditor/extract-enum-json-paths';
+export declare const stringifyDefaultProps: ({ props, enumPaths, }: {
+    props: unknown;
+    enumPaths: EnumPath[];
+}) => string;

package/dist/codemods/stringify-with-path.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyDefaultProps = void 0;
+const input_props_serialization_1 = require("../editor/components/RenderModal/SchemaEditor/input-props-serialization");
+const doesMatchPath = (path1, enumPaths) => {
+    return enumPaths.some((p) => path1.every((item, index) => {
+        if (p[index] === '[]' && !Number.isNaN(Number(item))) {
+            return true;
+        }
+        if (p[index] === '{}' && typeof item === 'string') {
+            return true;
+        }
+        return item === p[index];
+    }));
+};
+const stringifyDefaultProps = ({ props, enumPaths, }) => JSON.stringify(props, replacerWithPath(function (key, value, path) {
+    /* Don't replace with arrow function */ const item = this[key];
+    if (item instanceof Date) {
+        return `__REMOVEQUOTE__new Date('${item.toISOString()}')__REMOVEQUOTE__`;
+    }
+    if (typeof item === 'string' && doesMatchPath(path, enumPaths)) {
+        return `${item}__ADD_AS_CONST__`;
+    }
+    if (typeof item === 'string' && item.startsWith(input_props_serialization_1.FILE_TOKEN)) {
+        return `__REMOVEQUOTE____WRAP_IN_STATIC_FILE_START__${decodeURIComponent(item.replace(input_props_serialization_1.FILE_TOKEN, ''))}__WRAP_IN_STATIC_FILE_END____REMOVEQUOTE__`;
+    }
+    return value;
+}))
+    .replace(/"__REMOVEQUOTE__/g, '')
+    .replace(/__REMOVEQUOTE__"/g, '')
+    .replace(/__ADD_AS_CONST__"/g, '" as const')
+    .replace(/__WRAP_IN_STATIC_FILE_START__/g, 'staticFile("')
+    .replace(/__WRAP_IN_STATIC_FILE_END__/g, '")');
+exports.stringifyDefaultProps = stringifyDefaultProps;
+function replacerWithPath(replacer) {
+    const m = new Map();
+    return function (field, value) {
+        const path = [m.get(this), field].flat(1);
+        if (value === Object(value)) {
+            m.set(value, path);
+        }
+        return replacer.call(this, field, value, path.filter((item) => typeof item !== 'undefined' && item !== ''));
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { EnumPath } from '../editor/components/RenderModal/SchemaEditor/extract-enum-json-paths';
+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,128 @@
+"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 stringify_with_path_1 = require("./stringify-with-path");
+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;
+    }
+    const next = input.indexOf('}}', currentPosition + 1);
+    if (next !== -1) {
+        return next;
+    }
+    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, stringify_with_path_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;

package/dist/color-math.d.ts

@@ -0,0 +1,2 @@
+import type { ZodTypesType } from './editor/components/get-zod-if-possible';
+export declare const colorWithNewOpacity: (color: string, opacity: number, zodTypes: ZodTypesType) => string;

package/dist/color-math.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colorWithNewOpacity = void 0;
+const colorWithNewOpacity = (color, opacity, zodTypes) => {
+    const { r, g, b } = zodTypes.ZodZypesInternals.parseColor(color);
+    if (opacity >= 255) {
+        return `#${r.toString(16).padStart(2, '0')}${g
+            .toString(16)
+            .padStart(2, '0')}${b.toString(16).padStart(2, '0')}`;
+    }
+    return `rgba(${r}, ${g}, ${b}, ${(opacity / 255).toFixed(2)})`;
+};
+exports.colorWithNewOpacity = colorWithNewOpacity;

package/dist/composition-prompts.d.ts

@@ -0,0 +1,7 @@
+import type { PromptObject } from 'prompts';
+type Question<V extends string = string> = PromptObject<V> & {
+    optionsPerPage?: number;
+};
+type NamelessQuestion = Omit<Question<'value'>, 'name'>;
+export declare function selectAsync(question: NamelessQuestion): Promise<string | string[]>;
+export {};

package/dist/composition-prompts.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectAsync = void 0;
+const prompts_1 = __importDefault(require("prompts"));
+const log_1 = require("./log");
+function prompt(questions) {
+    return (0, prompts_1.default)([questions], {
+        onCancel() {
+            log_1.Log.error('No composition selected.');
+            process.exit(1);
+        },
+    });
+}
+async function selectAsync(question) {
+    const { value } = await prompt({
+        ...question,
+        name: 'value',
+        type: question.type,
+    });
+    return value !== null && value !== void 0 ? value : null;
+}
+exports.selectAsync = selectAsync;

package/dist/compositions.d.ts

@@ -1 +1 @@
-export declare const listCompositionsCommand: (remotionRoot: string) => Promise<void>;
+export declare const listCompositionsCommand: (remotionRoot: string, args: string[]) => Promise<void>;