bdy 1.18.8-dev → 1.18.9-dev-commands-changes-869c3r8yn

package/distTs/src/command/tests/unit/upload.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../utils");
+const texts_1 = require("../../../texts");
+const output_1 = __importDefault(require("../../../output"));
+const commander_1 = require("commander");
+const node_path_1 = __importDefault(require("node:path"));
+const token = process.env.BUDDY_UT_TOKEN || '';
+const commandUtUpload = (0, utils_1.newCommand)('upload', texts_1.DESC_COMMAND_UT_UPLOAD);
+commandUtUpload.argument('<glob>', texts_1.OPTION_UPLOAD_REPORT_GLOB);
+commandUtUpload.addOption(new commander_1.Option('--format <format>', texts_1.OPTION_UPLOAD_REPORT_FORMAT)
+    .choices(['junit-xml'])
+    .makeOptionMandatory());
+commandUtUpload.option('--dryRun', texts_1.OPTION_UPLOAD_DRY_RUN);
+commandUtUpload.action(async (input, options) => {
+    const { getCiInfo } = require('../../../unitTest/ci');
+    const { sendUploadRequest } = require('../../../unitTest/requests');
+    if (!token) {
+        output_1.default.exitError(texts_1.ERR_MISSING_UT_TOKEN);
+    }
+    const { glob, dryRun } = validateInputAndOptions(input, options);
+    const ciInfo = await getCiInfo();
+    const { absolutePattern, files } = findFilesByGlob(glob);
+    if (files.length === 0) {
+        output_1.default.exitError(`No files matched the provided glob: ${absolutePattern}`);
+    }
+    if (dryRun) {
+        output_1.default.normal(`Found ${files.length} report file(s) using pattern: ${absolutePattern}`);
+        files.forEach((file) => {
+            output_1.default.normal(file);
+        });
+        output_1.default.exitSuccess('Dry run completed');
+    }
+    await sendUploadRequest(files, ciInfo);
+    output_1.default.exitSuccess('Upload completed');
+});
+exports.default = commandUtUpload;
+function validateInputAndOptions(input, options) {
+    const z = require('zod');
+    const { ZodError } = require('zod');
+    const globSchema = z.string();
+    const optionsSchema = z.object({
+        format: z.enum(['junit-xml']),
+        dryRun: z.boolean().optional(),
+    });
+    try {
+        const glob = globSchema.parse(input);
+        const { format, dryRun } = optionsSchema.parse(options);
+        return {
+            glob,
+            format,
+            dryRun,
+        };
+    }
+    catch (error) {
+        if (error instanceof ZodError) {
+            output_1.default.exitError(error.errors.map((e) => `${e.path}: ${e.message}`).join(', '));
+        }
+        else {
+            throw error;
+        }
+    }
+}
+function findFilesByGlob(pattern) {
+    const { fdir } = require('fdir');
+    const picomatch = require('picomatch');
+    const cwd = process.cwd();
+    const scan = picomatch.scan(pattern);
+    if (!scan.isGlob) {
+        return {
+            absolutePattern: pattern,
+            files: (0, utils_1.isFile)(pattern) ? [pattern] : [],
+        };
+    }
+    if (node_path_1.default.isAbsolute(pattern)) {
+        const root = scan.base;
+        const files = new fdir().withFullPaths().glob(pattern).crawl(root).sync();
+        return { absolutePattern: pattern, files };
+    }
+    const preparedPattern = node_path_1.default.resolve(cwd, pattern);
+    const files = new fdir().withFullPaths().glob(preparedPattern).crawl().sync();
+    return { absolutePattern: preparedPattern, files };
+}

package/distTs/src/command/tests/unit.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const texts_1 = require("../../texts");
+const upload_1 = __importDefault(require("./unit/upload"));
+const commandUnit = (0, utils_1.newCommand)('unit', texts_1.DESC_COMMAND_UNIT);
+commandUnit.addCommand(upload_1.default);
+exports.default = commandUnit;

package/distTs/src/command/tests/visual/session/close.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../../utils");
+const texts_1 = require("../../../../texts");
+const output_1 = __importDefault(require("../../../../output"));
+const commandSessionClose = (0, utils_1.newCommand)('close', texts_1.DESC_COMMAND_SESSION_CLOSE);
+commandSessionClose.action(async () => {
+    const { checkBuildId, checkToken } = require('../../../../visualTest/validation');
+    const { closeSession } = require('../../../../visualTest/requests');
+    if (!checkToken('vt')) {
+        output_1.default.exitError(texts_1.ERR_MISSING_VT_TOKEN);
+    }
+    if (!checkBuildId()) {
+        output_1.default.exitError(texts_1.ERR_MISSING_BUILD_ID);
+    }
+    try {
+        const { message } = await closeSession();
+        output_1.default.exitNormal(message);
+    }
+    catch (error) {
+        output_1.default.exitError(`${error}`);
+    }
+});
+exports.default = commandSessionClose;

package/distTs/src/command/tests/visual/session/create.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../../utils");
+const texts_1 = require("../../../../texts");
+const output_1 = __importDefault(require("../../../../output"));
+const commandSessionCreate = (0, utils_1.newCommand)('create', texts_1.DESC_COMMAND_SESSION_CREATE);
+commandSessionCreate.argument('<command>', texts_1.OPTION_EXEC_COMMAND);
+commandSessionCreate.option('--skipDiscovery', texts_1.OPTION_EXEC_SKIP_DISCOVERY);
+commandSessionCreate.option('--oneByOne', texts_1.OPTION_EXEC_ONE_BY_ONE);
+commandSessionCreate.option('--parallel', texts_1.OPTION_EXEC_PARALLEL);
+commandSessionCreate.action(async (command, options) => {
+    const which = require('which');
+    const { getCiAndGitInfo, formattedCiInfo } = require('@buddy-works/ci-info');
+    const { checkParallel, checkToken } = require('../../../../visualTest/validation');
+    const { getDefaultSettings } = require('../../../../visualTest/requests');
+    const { debug, setBrowserPath, setCiAndCommitInfo, setExecOptions } = require('../../../../visualTest/context');
+    const { createServer } = require('../../../../visualTest/server');
+    const { finishProcessingSnapshots, setDefaultSettings, showSessionLink } = require('../../../../visualTest/snapshots');
+    const { testExec } = require('../../../../visualTest/exec');
+    const { getBrowserPath } = require('../../../../visualTest/browser');
+    setExecOptions(options);
+    try {
+        const browserPath = await getBrowserPath();
+        setBrowserPath(browserPath);
+    }
+    catch (error) {
+        output_1.default.exitError(`${error}`);
+    }
+    if (!checkToken('vt')) {
+        output_1.default.exitError(texts_1.ERR_MISSING_VT_TOKEN);
+    }
+    if (!checkParallel()) {
+        output_1.default.exitError(texts_1.ERR_MISSING_BUILD_ID);
+    }
+    const app = await createServer();
+    const [mainCommand, ...mainCommandArguments] = command.split(' ');
+    output_1.default.normal((0, texts_1.LOG_RUNNING_EXEC_COMMAND)(`${mainCommand} ${[...mainCommandArguments].join(' ')}`));
+    const resolved = await which(mainCommand, { nothrow: true });
+    if (!resolved) {
+        output_1.default.exitError((0, texts_1.ERR_MISSING_EXEC_COMMAND)(`${mainCommand} ${[...mainCommandArguments].join(' ')}`));
+    }
+    try {
+        let t1, t11;
+        if (debug) {
+            t1 = performance.now();
+        }
+        const defaultSettings = await getDefaultSettings();
+        setDefaultSettings(defaultSettings);
+        const ciAndGitInfo = await getCiAndGitInfo({
+            baseBranch: defaultSettings.baseBranch,
+            logger: output_1.default.warning,
+        });
+        setCiAndCommitInfo(ciAndGitInfo);
+        output_1.default.normal(formattedCiInfo(ciAndGitInfo));
+        if (debug) {
+            t11 = performance.now();
+        }
+        const spawnedProcessExitCode = await testExec(mainCommand, [
+            ...mainCommandArguments,
+        ]);
+        if (debug && t11) {
+            const t22 = performance.now();
+            output_1.default.normal((0, texts_1.DEBUG_EXEC_TEST_COMMAND)(t22 - t11));
+        }
+        await app.close();
+        await finishProcessingSnapshots(spawnedProcessExitCode);
+        showSessionLink();
+        if (debug && t1) {
+            const t2 = performance.now();
+            output_1.default.normal((0, texts_1.DEBUG_EXEC_COMMAND)(t2 - t1));
+        }
+        process.exit(spawnedProcessExitCode);
+    }
+    catch (error) {
+        await app.close();
+        output_1.default.exitError(`${error}`);
+    }
+});
+exports.default = commandSessionCreate;

package/distTs/src/command/tests/visual/session.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../utils");
+const texts_1 = require("../../../texts");
+const create_1 = __importDefault(require("./session/create"));
+const close_1 = __importDefault(require("./session/close"));
+const commandSession = (0, utils_1.newCommand)('session', texts_1.DESC_COMMAND_SESSION);
+commandSession.addCommand(create_1.default);
+commandSession.addCommand(close_1.default);
+exports.default = commandSession;

package/distTs/src/command/tests/visual/setup.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../utils");
+const texts_1 = require("../../../texts");
+const output_1 = __importDefault(require("../../../output"));
+const commandVisualSetup = (0, utils_1.newCommand)('setup', texts_1.DESC_COMMAND_VISUAL_SETUP);
+commandVisualSetup.action(async () => {
+    try {
+        const { installBrowser } = require('../../../visualTest/browser');
+        await installBrowser();
+        output_1.default.exitNormal('');
+    }
+    catch (error) {
+        output_1.default.exitError(`${error}`);
+    }
+});
+exports.default = commandVisualSetup;

package/distTs/src/command/tests/visual/shared/validation.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForSchema = exports.headerSchema = exports.cookieSchema = exports.DEFAULT_SCOPE = void 0;
+exports.parseScopedSelector = parseScopedSelector;
+exports.parseScopedKeyValue = parseScopedKeyValue;
+const zod_1 = require("zod");
+const output_1 = __importDefault(require("../../../../output"));
+exports.DEFAULT_SCOPE = '**';
+function parseScopedSelector(value) {
+    return value?.map((v) => {
+        let scope, type, selectorValue;
+        if (v.includes('::CSS=') || v.includes('::XPATH=')) {
+            const [scopePart, ...rest] = v.split('::');
+            const [typePart, ...valuePart] = rest.join('::').split('=');
+            type = typePart;
+            selectorValue = valuePart.join('=');
+            scope = scopePart;
+        }
+        else {
+            const [typePart, ...valuePart] = v.split('=');
+            type = typePart;
+            selectorValue = valuePart.join('=');
+            scope = exports.DEFAULT_SCOPE;
+        }
+        return { scope, type, value: selectorValue };
+    });
+}
+function parseScopedKeyValue(rawValue) {
+    let scope = exports.DEFAULT_SCOPE;
+    let keyValue = rawValue;
+    const scopeSeparatorIndex = rawValue.indexOf('::');
+    if (scopeSeparatorIndex >= 0) {
+        scope = rawValue.slice(0, scopeSeparatorIndex).trim();
+        keyValue = rawValue.slice(scopeSeparatorIndex + 2).trim();
+    }
+    const equalSignIndex = keyValue.indexOf('=');
+    if (equalSignIndex <= 0) {
+        output_1.default.exitError("Option value must follow pattern '[scope::]key=value' (scope is optional)");
+    }
+    const key = keyValue.slice(0, equalSignIndex).trim();
+    const value = keyValue.slice(equalSignIndex + 1).trim();
+    if (!key) {
+        output_1.default.exitError('Option key cannot be empty');
+    }
+    return { scope, key, value };
+}
+exports.cookieSchema = zod_1.z
+    .array(zod_1.z
+    .string()
+    .max(4096, {
+    message: 'Cookie must be less than 4096 characters',
+})
+    .regex(/^(?:([^:]+)::)?([^=]+)=(.*)$/, {
+    message: "Cookie option must follow pattern '[scope::]key=value[;attribute]' (scope is optional)",
+}))
+    .optional()
+    .transform((value) => value?.map((v) => {
+    let scope = exports.DEFAULT_SCOPE;
+    let cookieValue = v;
+    if (v.includes('::')) {
+        const [scopePart, valuePart] = v.split('::');
+        scope = scopePart.trim();
+        cookieValue = valuePart.trim();
+    }
+    const cookieParts = cookieValue.split(';').map((part) => part.trim());
+    const mainPart = cookieParts[0];
+    const firstEqualSignIndex = mainPart.indexOf('=');
+    const key = mainPart.slice(0, firstEqualSignIndex).trim();
+    const value = mainPart.slice(firstEqualSignIndex + 1).trim();
+    const cookie = {
+        scope,
+        key,
+        value,
+        httpOnly: false,
+        secure: false,
+    };
+    for (let i = 1; i < cookieParts.length; i++) {
+        const part = cookieParts[i].toLowerCase();
+        if (part === 'httponly') {
+            cookie.httpOnly = true;
+        }
+        else if (part === 'secure') {
+            cookie.secure = true;
+        }
+        else if (part.startsWith('domain=')) {
+            cookie.domain = part.substring(7);
+        }
+        else if (part.startsWith('path=')) {
+            cookie.path = part.substring(5);
+        }
+        else if (part.startsWith('samesite=')) {
+            const sameSiteValue = part.substring(9);
+            if (['strict', 'lax', 'none'].includes(sameSiteValue)) {
+                cookie.sameSite = (sameSiteValue.charAt(0).toUpperCase() +
+                    sameSiteValue.slice(1));
+            }
+        }
+    }
+    return cookie;
+}));
+exports.headerSchema = zod_1.z
+    .array(zod_1.z.string().regex(/^(?:([^:]+)::)?([^=]+)=(.*)$/, {
+    message: "Header option must follow pattern '[scope::]key=value' (scope is optional)",
+}))
+    .optional()
+    .transform((value) => value?.map((v) => {
+    const { scope, key, value } = parseScopedKeyValue(v);
+    return { scope, key, value };
+}));
+exports.waitForSchema = zod_1.z
+    .array(zod_1.z.string().regex(/^(?:([^:]+)::)?(?:(CSS|XPATH))=(.+)$/, {
+    message: "WaitFor option must follow pattern '[scope::]type=value' where type must be CSS or XPATH (scope is optional)",
+}))
+    .optional()
+    .transform(parseScopedSelector);

package/distTs/src/command/tests/visual/upload.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../utils");
+const texts_1 = require("../../../texts");
+const output_1 = __importDefault(require("../../../output"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_zlib_1 = require("node:zlib");
+const commandVisualUpload = (0, utils_1.newCommand)('upload', texts_1.DESC_COMMAND_VISUAL_UPLOAD);
+commandVisualUpload.action(async () => {
+    const { getCiAndGitInfo, formattedCiInfo } = require('@buddy-works/ci-info');
+    const { checkToken } = require('../../../visualTest/validation');
+    const { getDefaultSettings, sendStorybook } = require('../../../visualTest/requests');
+    const { setDefaultSettings } = require('../../../visualTest/snapshots');
+    const { setCiAndCommitInfo } = require('../../../visualTest/context');
+    if (!checkToken('vt')) {
+        output_1.default.exitError(texts_1.ERR_MISSING_VT_TOKEN);
+    }
+    const currentDirectoryFiles = getCurrentDirectoryFiles();
+    if (!isStorybookDirectory(currentDirectoryFiles)) {
+        output_1.default.exitError(texts_1.ERR_WRONG_STORYBOOK_DIRECTORY);
+    }
+    const storybookStoriesIndex = getStorybookStoriesIndex(currentDirectoryFiles);
+    const storiesList = getStoriesList(storybookStoriesIndex);
+    const storybookSnapshots = getStorybookSnapshots(storiesList);
+    const defaultSettings = await getDefaultSettings();
+    setDefaultSettings(defaultSettings);
+    const ciAndGitInfo = await getCiAndGitInfo({
+        baseBranch: defaultSettings.baseBranch,
+        logger: output_1.default.warning,
+    });
+    setCiAndCommitInfo(ciAndGitInfo);
+    output_1.default.normal(formattedCiInfo(ciAndGitInfo));
+    try {
+        const compressedStorybookDirectory = await createCompressedStorybookDirectory(currentDirectoryFiles);
+        const { message } = await sendStorybook(storybookSnapshots, compressedStorybookDirectory);
+        output_1.default.exitSuccess(message);
+    }
+    catch (error) {
+        output_1.default.exitError(`${error}`);
+    }
+});
+function getCurrentDirectoryFiles() {
+    const cwd = process.cwd();
+    const filesAndDirectories = (0, node_fs_1.readdirSync)(cwd, {
+        encoding: 'utf8',
+        recursive: true,
+    });
+    return filesAndDirectories.filter((file) => {
+        const elementPath = node_path_1.default.join(cwd, file);
+        const stats = (0, node_fs_1.statSync)(elementPath);
+        return stats.isFile();
+    });
+}
+async function createCompressedStorybookDirectory(files) {
+    const tar = require('tar-stream');
+    const cwd = process.cwd();
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+        const compressStream = (0, node_zlib_1.createBrotliCompress)({
+            params: {
+                [node_zlib_1.constants.BROTLI_PARAM_QUALITY]: 6,
+            },
+        });
+        compressStream.on('data', (chunk) => {
+            chunks.push(chunk);
+        });
+        compressStream.on('end', () => {
+            resolve(Buffer.concat(chunks));
+        });
+        compressStream.on('error', reject);
+        const packStream = tar.pack();
+        packStream.pipe(compressStream);
+        let filesProcessed = 0;
+        for (const file of files) {
+            const filePath = node_path_1.default.join(cwd, file);
+            const stats = (0, node_fs_1.statSync)(filePath);
+            const entry = packStream.entry({
+                name: file,
+                size: stats.size,
+            }, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    filesProcessed += 1;
+                    if (filesProcessed === files.length) {
+                        packStream.finalize();
+                    }
+                }
+            });
+            const fileStream = (0, node_fs_1.createReadStream)(filePath);
+            fileStream.pipe(entry);
+            fileStream.on('error', reject);
+        }
+    });
+}
+function isStorybookDirectory(files) {
+    return (files.length > 0 &&
+        files.includes('index.html') &&
+        files.includes('iframe.html'));
+}
+function getStorybookStoriesIndex(files) {
+    const indexFiles = files.find((file) => file === 'index.json');
+    if (indexFiles) {
+        return indexFiles;
+    }
+    else {
+        return output_1.default.exitError(texts_1.ERR_MISSING_STORYBOOK_INDEX_FILE);
+    }
+}
+function getStoriesList(storybookStoriesIndex) {
+    const storiesListFile = (0, node_fs_1.readFileSync)(storybookStoriesIndex);
+    try {
+        const json = JSON.parse(storiesListFile.toString());
+        if (![4, 5].includes(json.v)) {
+            output_1.default.exitError(texts_1.ERR_UNSUPPORTED_STORYBOOK);
+        }
+        return json;
+    }
+    catch {
+        output_1.default.exitError(texts_1.ERR_PARSING_STORIES);
+    }
+}
+function getStorybookSnapshots(storiesList) {
+    const stories = Object.entries(storiesList.entries)
+        .filter(([, value]) => value.type === 'story')
+        .map(([key, value]) => ({
+        id: key,
+        name: `${value.title}/${value.name}`,
+    }));
+    output_1.default.normal((0, texts_1.TXT_STORIES_AMOUNT)(stories.length));
+    return stories;
+}
+exports.default = commandVisualUpload;

package/distTs/src/command/tests/visual.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const texts_1 = require("../../texts");
+const setup_1 = __importDefault(require("./visual/setup"));
+const upload_1 = __importDefault(require("./visual/upload"));
+const session_1 = __importDefault(require("./visual/session"));
+const commandVisual = (0, utils_1.newCommand)('visual', texts_1.DESC_COMMAND_VISUAL);
+commandVisual.addCommand(setup_1.default);
+commandVisual.addCommand(upload_1.default);
+commandVisual.addCommand(session_1.default);
+exports.default = commandVisual;

package/distTs/src/command/tests.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const texts_1 = require("../texts");
+const unit_1 = __importDefault(require("./tests/unit"));
+const visual_1 = __importDefault(require("./tests/visual"));
+const capture_1 = __importDefault(require("./tests/capture"));
+const commandTests = (0, utils_1.newCommand)('tests', texts_1.DESC_COMMAND_TESTS);
+commandTests.addCommand(unit_1.default);
+commandTests.addCommand(visual_1.default);
+commandTests.addCommand(capture_1.default);
+exports.default = commandTests;

package/distTs/src/command/ut/upload.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -7,7 +40,12 @@ const utils_1 = require("../../utils");
 const texts_1 = require("../../texts");
 const output_1 = __importDefault(require("../../output"));
 const commander_1 = require("commander");
+const zod_1 = __importStar(require("zod"));
+const fdir_1 = require("fdir");
+const picomatch_1 = __importDefault(require("picomatch"));
 const node_path_1 = __importDefault(require("node:path"));
+const ci_1 = require("../../unitTest/ci");
+const requests_1 = require("../../unitTest/requests");
 const token = process.env.BUDDY_UT_TOKEN || '';
 const commandUtUpload = (0, utils_1.newCommand)('upload', texts_1.DESC_COMMAND_UT_UPLOAD);
 commandUtUpload.argument('<glob>', texts_1.OPTION_UPLOAD_REPORT_GLOB);
@@ -16,13 +54,11 @@ commandUtUpload.addOption(new commander_1.Option('--format <format>', texts_1.OP
     .makeOptionMandatory());
 commandUtUpload.option('--dryRun', texts_1.OPTION_UPLOAD_DRY_RUN);
 commandUtUpload.action(async (input, options) => {
-    const { getCiInfo } = require('../../unitTest/ci');
-    const { sendUploadRequest } = require('../../unitTest/requests');
     if (!token) {
         output_1.default.exitError(texts_1.ERR_MISSING_UT_TOKEN);
     }
     const { glob, dryRun } = validateInputAndOptions(input, options);
-    const ciInfo = await getCiInfo();
+    const ciInfo = await (0, ci_1.getCiInfo)();
     const { absolutePattern, files } = findFilesByGlob(glob);
     if (files.length === 0) {
         output_1.default.exitError(`No files matched the provided glob: ${absolutePattern}`);
@@ -34,17 +70,15 @@ commandUtUpload.action(async (input, options) => {
         });
         output_1.default.exitSuccess('Dry run completed');
     }
-    await sendUploadRequest(files, ciInfo);
+    await (0, requests_1.sendUploadRequest)(files, ciInfo);
     output_1.default.exitSuccess('Upload completed');
 });
 exports.default = commandUtUpload;
 function validateInputAndOptions(input, options) {
-    const z = require('zod');
-    const { ZodError } = require('zod');
-    const globSchema = z.string();
-    const optionsSchema = z.object({
-        format: z.enum(['junit-xml']),
-        dryRun: z.boolean().optional(),
+    const globSchema = zod_1.default.string();
+    const optionsSchema = zod_1.default.object({
+        format: zod_1.default.enum(['junit-xml']),
+        dryRun: zod_1.default.boolean().optional(),
     });
     try {
         const glob = globSchema.parse(input);
@@ -56,7 +90,7 @@ function validateInputAndOptions(input, options) {
         };
     }
     catch (error) {
-        if (error instanceof ZodError) {
+        if (error instanceof zod_1.ZodError) {
             output_1.default.exitError(error.errors.map((e) => `${e.path}: ${e.message}`).join(', '));
         }
         else {
@@ -65,10 +99,8 @@ function validateInputAndOptions(input, options) {
     }
 }
 function findFilesByGlob(pattern) {
-    const { fdir } = require('fdir');
-    const picomatch = require('picomatch');
     const cwd = process.cwd();
-    const scan = picomatch.scan(pattern);
+    const scan = picomatch_1.default.scan(pattern);
     if (!scan.isGlob) {
         return {
             absolutePattern: pattern,
@@ -77,10 +109,10 @@ function findFilesByGlob(pattern) {
     }
     if (node_path_1.default.isAbsolute(pattern)) {
         const root = scan.base;
-        const files = new fdir().withFullPaths().glob(pattern).crawl(root).sync();
+        const files = new fdir_1.fdir().withFullPaths().glob(pattern).crawl(root).sync();
         return { absolutePattern: pattern, files };
     }
     const preparedPattern = node_path_1.default.resolve(cwd, pattern);
-    const files = new fdir().withFullPaths().glob(preparedPattern).crawl().sync();
+    const files = new fdir_1.fdir().withFullPaths().glob(preparedPattern).crawl().sync();
     return { absolutePattern: preparedPattern, files };
 }