@testingbot/cli 1.0.0

package/dist/providers/xcuitest.d.ts

@@ -0,0 +1,67 @@
+import XCUITestOptions from '../models/xcuitest_options';
+import Credentials from '../models/credentials';
+export interface XCUITestRunInfo {
+    id: number;
+    status: 'WAITING' | 'READY' | 'DONE' | 'FAILED';
+    capabilities: {
+        deviceName: string;
+        platformName: string;
+        version?: string;
+    };
+    success: number;
+    report?: string;
+}
+export interface XCUITestStatusResponse {
+    runs: XCUITestRunInfo[];
+    success: boolean;
+    completed: boolean;
+}
+export interface XCUITestResult {
+    success: boolean;
+    runs: XCUITestRunInfo[];
+}
+export interface XCUITestSocketMessage {
+    id: number;
+    payload: string;
+}
+export default class XCUITest {
+    private readonly URL;
+    private readonly POLL_INTERVAL_MS;
+    private readonly MAX_POLL_ATTEMPTS;
+    private credentials;
+    private options;
+    private upload;
+    private appId;
+    private activeRunIds;
+    private isShuttingDown;
+    private signalHandler;
+    private socket;
+    private updateServer;
+    private updateKey;
+    constructor(credentials: Credentials, options: XCUITestOptions);
+    private validate;
+    private ensureOutputDirectory;
+    run(): Promise<XCUITestResult>;
+    private uploadApp;
+    private uploadTestApp;
+    private runTests;
+    private getStatus;
+    private waitForCompletion;
+    private displayRunStatus;
+    private clearLine;
+    private formatElapsedTime;
+    private getStatusInfo;
+    private fetchReports;
+    private sleep;
+    private extractErrorMessage;
+    private setupSignalHandlers;
+    private removeSignalHandlers;
+    private handleShutdown;
+    private stopActiveRuns;
+    private stopRun;
+    private connectToUpdateServer;
+    private disconnectFromUpdateServer;
+    private handleXCUITestData;
+    private handleXCUITestError;
+}
+//# sourceMappingURL=xcuitest.d.ts.map

package/dist/providers/xcuitest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xcuitest.d.ts","sourceRoot":"","sources":["../../src/providers/xcuitest.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,MAAM,4BAA4B,CAAC;AAEzD,OAAO,WAAW,MAAM,uBAAuB,CAAC;AAUhD,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IAChD,YAAY,EAAE;QACZ,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,eAAe,EAAE,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,eAAe,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC3B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAyD;IAC7E,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAQ;IACzC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAO;IAEzC,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,aAAa,CAA6B;IAClD,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,SAAS,CAAuB;gBAErB,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,eAAe;YAMvD,QAAQ;YAuCR,qBAAqB;IA6BtB,GAAG,IAAI,OAAO,CAAC,cAAc,CAAC;YA4D7B,SAAS;YAaT,aAAa;YAYb,QAAQ;YAsDR,SAAS;YAoBT,iBAAiB;IAwE/B,OAAO,CAAC,gBAAgB;IAmCxB,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,iBAAiB;IASzB,OAAO,CAAC,aAAa;YAkBP,YAAY;IAsD1B,OAAO,CAAC,KAAK;IAIb,OAAO,CAAC,mBAAmB;IAiD3B,OAAO,CAAC,mBAAmB;IAQ3B,OAAO,CAAC,oBAAoB;IAO5B,OAAO,CAAC,cAAc;YAuBR,cAAc;YAgBd,OAAO;IA8BrB,OAAO,CAAC,qBAAqB;IAqC7B,OAAO,CAAC,0BAA0B;IAOlC,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,mBAAmB;CAa5B"}

package/dist/providers/xcuitest.js

@@ -0,0 +1,529 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = __importDefault(require("../logger"));
+const axios_1 = __importDefault(require("axios"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const socket_io_client_1 = require("socket.io-client");
+const testingbot_error_1 = __importDefault(require("../models/testingbot_error"));
+const utils_1 = __importDefault(require("../utils"));
+const upload_1 = __importDefault(require("../upload"));
+const platform_1 = __importDefault(require("../utils/platform"));
+class XCUITest {
+    URL = 'https://api.testingbot.com/v1/app-automate/xcuitest';
+    POLL_INTERVAL_MS = 5000;
+    MAX_POLL_ATTEMPTS = 720; // 1 hour max with 5s interval
+    credentials;
+    options;
+    upload;
+    appId = undefined;
+    activeRunIds = [];
+    isShuttingDown = false;
+    signalHandler = null;
+    socket = null;
+    updateServer = null;
+    updateKey = null;
+    constructor(credentials, options) {
+        this.credentials = credentials;
+        this.options = options;
+        this.upload = new upload_1.default();
+    }
+    async validate() {
+        if (this.options.app === undefined) {
+            throw new testingbot_error_1.default(`app option is required`);
+        }
+        try {
+            await node_fs_1.default.promises.access(this.options.app, node_fs_1.default.constants.R_OK);
+        }
+        catch {
+            throw new testingbot_error_1.default(`Provided app path does not exist ${this.options.app}`);
+        }
+        if (this.options.testApp === undefined) {
+            throw new testingbot_error_1.default(`testApp option is required`);
+        }
+        try {
+            await node_fs_1.default.promises.access(this.options.testApp, node_fs_1.default.constants.R_OK);
+        }
+        catch {
+            throw new testingbot_error_1.default(`testApp path does not exist ${this.options.testApp}`);
+        }
+        // Validate report options
+        if (this.options.report && !this.options.reportOutputDir) {
+            throw new testingbot_error_1.default(`--report-output-dir is required when --report is specified`);
+        }
+        if (this.options.reportOutputDir) {
+            await this.ensureOutputDirectory(this.options.reportOutputDir);
+        }
+        return true;
+    }
+    async ensureOutputDirectory(dirPath) {
+        try {
+            const stat = await node_fs_1.default.promises.stat(dirPath);
+            if (!stat.isDirectory()) {
+                throw new testingbot_error_1.default(`Report output path exists but is not a directory: ${dirPath}`);
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                try {
+                    await node_fs_1.default.promises.mkdir(dirPath, { recursive: true });
+                }
+                catch (mkdirError) {
+                    throw new testingbot_error_1.default(`Failed to create report output directory: ${dirPath}`, { cause: mkdirError });
+                }
+            }
+            else if (error instanceof testingbot_error_1.default) {
+                throw error;
+            }
+            else {
+                throw new testingbot_error_1.default(`Failed to access report output directory: ${dirPath}`, { cause: error });
+            }
+        }
+    }
+    async run() {
+        if (!(await this.validate())) {
+            return { success: false, runs: [] };
+        }
+        try {
+            if (!this.options.quiet) {
+                logger_1.default.info('Uploading XCUITest App');
+            }
+            await this.uploadApp();
+            if (!this.options.quiet) {
+                logger_1.default.info('Uploading XCUITest Test App');
+            }
+            await this.uploadTestApp();
+            if (!this.options.quiet) {
+                logger_1.default.info('Running XCUITests');
+            }
+            await this.runTests();
+            if (this.options.async) {
+                if (!this.options.quiet) {
+                    logger_1.default.info(`Tests started in async mode. Project ID: ${this.appId}`);
+                }
+                return { success: true, runs: [] };
+            }
+            // Set up signal handlers before waiting for completion
+            this.setupSignalHandlers();
+            // Connect to real-time update server (unless --quiet is specified)
+            this.connectToUpdateServer();
+            if (!this.options.quiet) {
+                logger_1.default.info('Waiting for test results...');
+            }
+            const result = await this.waitForCompletion();
+            // Clean up
+            this.disconnectFromUpdateServer();
+            this.removeSignalHandlers();
+            return result;
+        }
+        catch (error) {
+            // Clean up on error
+            this.disconnectFromUpdateServer();
+            this.removeSignalHandlers();
+            logger_1.default.error(error instanceof Error ? error.message : error);
+            if (error instanceof Error && error.cause) {
+                const causeMessage = this.extractErrorMessage(error.cause);
+                if (causeMessage) {
+                    logger_1.default.error(`  Reason: ${causeMessage}`);
+                }
+            }
+            return { success: false, runs: [] };
+        }
+    }
+    async uploadApp() {
+        const result = await this.upload.upload({
+            filePath: this.options.app,
+            url: `${this.URL}/app`,
+            credentials: this.credentials,
+            contentType: 'application/octet-stream',
+            showProgress: !this.options.quiet,
+        });
+        this.appId = result.id;
+        return true;
+    }
+    async uploadTestApp() {
+        await this.upload.upload({
+            filePath: this.options.testApp,
+            url: `${this.URL}/${this.appId}/tests`,
+            credentials: this.credentials,
+            contentType: 'application/zip',
+            showProgress: !this.options.quiet,
+        });
+        return true;
+    }
+    async runTests() {
+        try {
+            const capabilities = this.options.getCapabilities();
+            const xcuitestOptions = this.options.getXCUITestOptions();
+            const response = await axios_1.default.post(`${this.URL}/${this.appId}/run`, {
+                capabilities: [capabilities],
+                ...(xcuitestOptions && { options: xcuitestOptions }),
+            }, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'User-Agent': utils_1.default.getUserAgent(),
+                },
+                auth: {
+                    username: this.credentials.userName,
+                    password: this.credentials.accessKey,
+                },
+            });
+            // Check for version update notification
+            const latestVersion = response.headers?.['x-testingbotctl-version'];
+            utils_1.default.checkForUpdate(latestVersion);
+            const result = response.data;
+            // Capture real-time update server info
+            if (result.update_server && result.update_key) {
+                this.updateServer = result.update_server;
+                this.updateKey = result.update_key;
+            }
+            if (result.success === false) {
+                const errorMessage = result.errors?.join('\n') || result.error || 'Unknown error';
+                throw new testingbot_error_1.default(`Running XCUITest failed`, {
+                    cause: errorMessage,
+                });
+            }
+            return true;
+        }
+        catch (error) {
+            if (error instanceof testingbot_error_1.default) {
+                throw error;
+            }
+            throw new testingbot_error_1.default(`Running XCUITest failed`, {
+                cause: error,
+            });
+        }
+    }
+    async getStatus() {
+        try {
+            const response = await axios_1.default.get(`${this.URL}/${this.appId}`, {
+                headers: {
+                    'User-Agent': utils_1.default.getUserAgent(),
+                },
+                auth: {
+                    username: this.credentials.userName,
+                    password: this.credentials.accessKey,
+                },
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw new testingbot_error_1.default(`Failed to get XCUITest status`, {
+                cause: error,
+            });
+        }
+    }
+    async waitForCompletion() {
+        let attempts = 0;
+        const startTime = Date.now();
+        const previousStatus = new Map();
+        while (attempts < this.MAX_POLL_ATTEMPTS) {
+            if (this.isShuttingDown) {
+                throw new testingbot_error_1.default('Test run cancelled by user');
+            }
+            const status = await this.getStatus();
+            // Track active run IDs for graceful shutdown
+            this.activeRunIds = status.runs
+                .filter((run) => run.status !== 'DONE' && run.status !== 'FAILED')
+                .map((run) => run.id);
+            // Log current status of runs (unless quiet mode)
+            if (!this.options.quiet) {
+                this.displayRunStatus(status.runs, startTime, previousStatus);
+            }
+            if (status.completed) {
+                // Clear the updating line and print final status
+                if (!this.options.quiet) {
+                    this.clearLine();
+                    for (const run of status.runs) {
+                        const statusEmoji = run.success === 1 ? '✅' : '❌';
+                        const statusText = run.success === 1 ? 'Test completed successfully' : 'Test failed';
+                        console.log(`  ${statusEmoji} Run ${run.id} (${run.capabilities.deviceName}): ${statusText}`);
+                    }
+                }
+                const allSucceeded = status.runs.every((run) => run.success === 1);
+                if (allSucceeded) {
+                    if (!this.options.quiet) {
+                        logger_1.default.info('All tests completed successfully!');
+                    }
+                }
+                else {
+                    const failedRuns = status.runs.filter((run) => run.success !== 1);
+                    logger_1.default.error(`${failedRuns.length} test run(s) failed:`);
+                    for (const run of failedRuns) {
+                        logger_1.default.error(`  - Run ${run.id} (${run.capabilities.deviceName}): ${run.report || 'No report available'}`);
+                    }
+                }
+                // Fetch reports if requested
+                if (this.options.report && this.options.reportOutputDir) {
+                    await this.fetchReports(status.runs);
+                }
+                return {
+                    success: status.success,
+                    runs: status.runs,
+                };
+            }
+            attempts++;
+            await this.sleep(this.POLL_INTERVAL_MS);
+        }
+        throw new testingbot_error_1.default(`Test timed out after ${(this.MAX_POLL_ATTEMPTS * this.POLL_INTERVAL_MS) / 1000 / 60} minutes`);
+    }
+    displayRunStatus(runs, startTime, previousStatus) {
+        const elapsedSeconds = Math.floor((Date.now() - startTime) / 1000);
+        const elapsedStr = this.formatElapsedTime(elapsedSeconds);
+        for (const run of runs) {
+            const prevStatus = previousStatus.get(run.id);
+            const statusChanged = prevStatus !== run.status;
+            if (statusChanged &&
+                prevStatus &&
+                (prevStatus === 'WAITING' || prevStatus === 'READY')) {
+                this.clearLine();
+            }
+            previousStatus.set(run.id, run.status);
+            const statusInfo = this.getStatusInfo(run.status);
+            if (run.status === 'WAITING' || run.status === 'READY') {
+                const message = `  ${statusInfo.emoji} Run ${run.id} (${run.capabilities.deviceName}): ${statusInfo.text} (${elapsedStr})`;
+                process.stdout.write(`\r${message}`);
+            }
+            else if (statusChanged) {
+                console.log(`  ${statusInfo.emoji} Run ${run.id} (${run.capabilities.deviceName}): ${statusInfo.text}`);
+            }
+        }
+    }
+    clearLine() {
+        platform_1.default.clearLine();
+    }
+    formatElapsedTime(seconds) {
+        if (seconds < 60) {
+            return `${seconds}s`;
+        }
+        const minutes = Math.floor(seconds / 60);
+        const remainingSeconds = seconds % 60;
+        return `${minutes}m ${remainingSeconds}s`;
+    }
+    getStatusInfo(status) {
+        switch (status) {
+            case 'WAITING':
+                return { emoji: '⏳', text: 'Waiting for test to start' };
+            case 'READY':
+                return { emoji: '🔄', text: 'Running test' };
+            case 'DONE':
+                return { emoji: '✅', text: 'Test has finished running' };
+            case 'FAILED':
+                return { emoji: '❌', text: 'Test failed' };
+            default:
+                return { emoji: '❓', text: status };
+        }
+    }
+    async fetchReports(runs) {
+        const reportFormat = this.options.report;
+        const outputDir = this.options.reportOutputDir;
+        if (!reportFormat || !outputDir) {
+            return;
+        }
+        if (!this.options.quiet) {
+            logger_1.default.info(`Fetching ${reportFormat} report(s)...`);
+        }
+        for (const run of runs) {
+            try {
+                const endpoint = reportFormat === 'junit'
+                    ? `${this.URL}/${this.appId}/${run.id}/junit_report`
+                    : `${this.URL}/${this.appId}/${run.id}/html_report`;
+                const response = await axios_1.default.get(endpoint, {
+                    headers: {
+                        'User-Agent': utils_1.default.getUserAgent(),
+                    },
+                    auth: {
+                        username: this.credentials.userName,
+                        password: this.credentials.accessKey,
+                    },
+                    responseType: reportFormat === 'html' ? 'arraybuffer' : 'text',
+                });
+                const reportContent = response.data;
+                if (!reportContent) {
+                    logger_1.default.error(`No report content received for run ${run.id}`);
+                    continue;
+                }
+                const extension = reportFormat === 'junit' ? 'xml' : 'html';
+                const fileName = `xcuitest_report_${this.appId}_${run.id}.${extension}`;
+                const filePath = node_path_1.default.join(outputDir, fileName);
+                await node_fs_1.default.promises.writeFile(filePath, reportContent);
+                if (!this.options.quiet) {
+                    logger_1.default.info(`  Saved report: ${filePath}`);
+                }
+            }
+            catch (error) {
+                logger_1.default.error(`Failed to fetch report for run ${run.id}: ${error instanceof Error ? error.message : error}`);
+            }
+        }
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    extractErrorMessage(cause) {
+        if (typeof cause === 'string') {
+            return cause;
+        }
+        if (Array.isArray(cause)) {
+            return cause.join('\n');
+        }
+        if (cause && typeof cause === 'object') {
+            const axiosError = cause;
+            if (axiosError.response?.data?.errors) {
+                return axiosError.response.data.errors.join('\n');
+            }
+            if (axiosError.response?.data?.error) {
+                return axiosError.response.data.error;
+            }
+            if (axiosError.response?.data?.message) {
+                return axiosError.response.data.message;
+            }
+            if (cause instanceof Error) {
+                return cause.message;
+            }
+            const obj = cause;
+            if (obj.errors) {
+                return obj.errors.join('\n');
+            }
+            if (obj.error) {
+                return obj.error;
+            }
+            if (obj.message) {
+                return obj.message;
+            }
+        }
+        return null;
+    }
+    setupSignalHandlers() {
+        this.signalHandler = () => {
+            this.handleShutdown();
+        };
+        platform_1.default.setupSignalHandlers(this.signalHandler);
+    }
+    removeSignalHandlers() {
+        if (this.signalHandler) {
+            platform_1.default.removeSignalHandlers(this.signalHandler);
+            this.signalHandler = null;
+        }
+    }
+    handleShutdown() {
+        if (this.isShuttingDown) {
+            logger_1.default.warn('Force exiting...');
+            process.exit(1);
+        }
+        this.isShuttingDown = true;
+        this.clearLine();
+        logger_1.default.warn('Received interrupt signal, stopping test runs...');
+        this.stopActiveRuns()
+            .then(() => {
+            logger_1.default.info('All test runs have been stopped.');
+            process.exit(1);
+        })
+            .catch((error) => {
+            logger_1.default.error(`Failed to stop some test runs: ${error instanceof Error ? error.message : error}`);
+            process.exit(1);
+        });
+    }
+    async stopActiveRuns() {
+        if (!this.appId || this.activeRunIds.length === 0) {
+            return;
+        }
+        const stopPromises = this.activeRunIds.map((runId) => this.stopRun(runId).catch((error) => {
+            logger_1.default.error(`Failed to stop run ${runId}: ${error instanceof Error ? error.message : error}`);
+        }));
+        await Promise.all(stopPromises);
+    }
+    async stopRun(runId) {
+        if (!this.appId) {
+            return;
+        }
+        try {
+            await axios_1.default.post(`${this.URL}/${this.appId}/${runId}/stop`, {}, {
+                headers: {
+                    'User-Agent': utils_1.default.getUserAgent(),
+                },
+                auth: {
+                    username: this.credentials.userName,
+                    password: this.credentials.accessKey,
+                },
+            });
+            if (!this.options.quiet) {
+                logger_1.default.info(`  Stopped run ${runId}`);
+            }
+        }
+        catch (error) {
+            throw new testingbot_error_1.default(`Failed to stop run ${runId}`, {
+                cause: error,
+            });
+        }
+    }
+    connectToUpdateServer() {
+        if (!this.updateServer || !this.updateKey || this.options.quiet) {
+            return;
+        }
+        try {
+            this.socket = (0, socket_io_client_1.io)(this.updateServer, {
+                transports: ['websocket'],
+                reconnection: true,
+                reconnectionAttempts: 3,
+                reconnectionDelay: 1000,
+                timeout: 10000,
+            });
+            this.socket.on('connect', () => {
+                // Join the room for this test run
+                this.socket?.emit('join', this.updateKey);
+            });
+            this.socket.on('xcuitest_data', (data) => {
+                this.handleXCUITestData(data);
+            });
+            this.socket.on('xcuitest_error', (data) => {
+                this.handleXCUITestError(data);
+            });
+            this.socket.on('connect_error', () => {
+                // Silently fail - real-time updates are optional
+                this.disconnectFromUpdateServer();
+            });
+        }
+        catch {
+            // Socket connection failed, continue without real-time updates
+            this.socket = null;
+        }
+    }
+    disconnectFromUpdateServer() {
+        if (this.socket) {
+            this.socket.disconnect();
+            this.socket = null;
+        }
+    }
+    handleXCUITestData(data) {
+        try {
+            const message = JSON.parse(data);
+            if (message.payload) {
+                // Clear the status line before printing output
+                this.clearLine();
+                // Print the XCUITest output
+                process.stdout.write(message.payload);
+            }
+        }
+        catch {
+            // Invalid JSON, ignore
+        }
+    }
+    handleXCUITestError(data) {
+        try {
+            const message = JSON.parse(data);
+            if (message.payload) {
+                // Clear the status line before printing error
+                this.clearLine();
+                // Print the error output
+                process.stderr.write(message.payload);
+            }
+        }
+        catch {
+            // Invalid JSON, ignore
+        }
+    }
+}
+exports.default = XCUITest;

package/dist/upload.d.ts

@@ -0,0 +1,21 @@
+import Credentials from './models/credentials';
+export type ContentType = 'application/vnd.android.package-archive' | 'application/octet-stream' | 'application/zip';
+export interface UploadOptions {
+    filePath: string;
+    url: string;
+    credentials: Credentials;
+    contentType: ContentType;
+    showProgress?: boolean;
+}
+export interface UploadResult {
+    id: number;
+}
+export default class Upload {
+    private lastProgressPercent;
+    upload(options: UploadOptions): Promise<UploadResult>;
+    private validateFile;
+    private handleProgress;
+    private displayProgress;
+    private clearProgressLine;
+}
+//# sourceMappingURL=upload.d.ts.map

package/dist/upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../src/upload.ts"],"names":[],"mappings":"AAIA,OAAO,WAAW,MAAM,sBAAsB,CAAC;AAI/C,MAAM,MAAM,WAAW,GACnB,yCAAyC,GACzC,0BAA0B,GAC1B,iBAAiB,CAAC;AAEtB,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,WAAW,CAAC;IACzB,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,CAAC,OAAO,OAAO,MAAM;IACzB,OAAO,CAAC,mBAAmB,CAAa;IAE3B,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;YA+DpD,YAAY;IAQ1B,OAAO,CAAC,cAAc;IAetB,OAAO,CAAC,eAAe;IAmBvB,OAAO,CAAC,iBAAiB;CAI1B"}