bdy 1.18.31-dev → 1.18.31-dev-commands-changes-869c3r8yn

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

@@ -0,0 +1,103 @@
+"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 commandCapture = (0, utils_1.newCommand)('capture', texts_1.DESC_COMMAND_CAPTURE);
+commandCapture.option('--urls <urls>', texts_1.OPTION_COMPARE_URLS);
+commandCapture.option('--sitemap <sitemap>', texts_1.OPTION_COMPARE_SITEMAP);
+commandCapture.option('--urlsFile <urlsFile>', texts_1.OPTION_COMPARE_URLS_FILE);
+commandCapture.option('--dryRun', texts_1.OPTION_COMPARE_DRY_RUN);
+commandCapture.option('--follow', texts_1.OPTION_COMPARE_FOLLOW, false);
+commandCapture.option('--respectRobots', texts_1.OPTION_COMPARE_RESPECT_ROBOTS, false);
+commandCapture.option('--ignoreUrls <ignoreUrls...>', texts_1.OPTION_COMPARE_IGNORE_URLS);
+commandCapture.option('--ignore <ignores...>', texts_1.OPTION_COMPARE_IGNORE);
+commandCapture.option('--cookie <cookies...>', texts_1.OPTION_COMPARE_COOKIE);
+commandCapture.option('--header <headers...>', texts_1.OPTION_COMPARE_HEADER);
+commandCapture.option('--delay <delays...>', texts_1.OPTION_COMPARE_DELAY);
+commandCapture.option('--waitFor <waitFors...>', texts_1.OPTION_COMPARE_WAIT_FOR);
+commandCapture.action(async (options) => {
+    const { getCiAndGitInfo, formattedCiInfo } = require('@buddy-works/ci-info');
+    const { addProtocolIfMissing } = require('../../visualTest/linkUtils');
+    const { sendCompareLinks } = require('../../visualTest/requests');
+    const { checkIfMinimalOptionsAreProvided, validateOptions } = require('./capture/validation');
+    const { createVtContext, applyToken, applyCiAndCommitInfo } = require('../../visualTest/context');
+    const validatedOptions = validateOptions(options);
+    const Input = require('../../input').default;
+    const token = await Input.vtSuiteToken();
+    if (!token) {
+        output_1.default.exitError(texts_1.ERR_MISSING_VT_TOKEN);
+    }
+    const ctx = createVtContext();
+    applyToken(ctx, token);
+    if (!checkIfMinimalOptionsAreProvided(validatedOptions)) {
+        output_1.default.exitError(texts_1.ERR_MISSING_URLS);
+    }
+    let urls = [];
+    let sitemapSource;
+    if (validatedOptions.urls) {
+        const urlsList = getUrlsFromUrlOption(validatedOptions.urls);
+        urls = urls.concat(urlsList);
+    }
+    if (validatedOptions.urlsFile) {
+        const urlsList = getUrlsFromUrlFile(validatedOptions.urlsFile);
+        urls = urls.concat(urlsList);
+    }
+    if (validatedOptions.sitemap) {
+        sitemapSource = addProtocolIfMissing(validatedOptions.sitemap);
+    }
+    const { filteredUrls, duplicates } = filterDuplicates(urls);
+    if (duplicates.length > 0) {
+        output_1.default.normal(`Detected ${duplicates.length} duplicated urls:`);
+        output_1.default.normal(duplicates.join('\n'));
+    }
+    if (validatedOptions.dryRun) {
+        output_1.default.exitSuccess(`List of urls:\n${filteredUrls.join('\n')}`);
+    }
+    else if (filteredUrls.length > 1) {
+        output_1.default.normal(`List of urls:\n${filteredUrls.join('\n')}`);
+    }
+    const ciAndGitInfo = await getCiAndGitInfo({});
+    output_1.default.normal(formattedCiInfo(ciAndGitInfo));
+    applyCiAndCommitInfo(ctx, ciAndGitInfo);
+    try {
+        const { message } = await sendCompareLinks(ctx, filteredUrls, validatedOptions, sitemapSource);
+        output_1.default.exitSuccess(message);
+    }
+    catch (error) {
+        output_1.default.exitError(`${error}`);
+    }
+});
+function getUrlsFromUrlOption(urls) {
+    const { addProtocolIfMissing } = require('../../visualTest/linkUtils');
+    return urls.split(',').map((url) => addProtocolIfMissing(url).trim());
+}
+function getUrlsFromUrlFile(urlsFile) {
+    const { addProtocolIfMissing } = require('../../visualTest/linkUtils');
+    const urlsFromFile = (0, node_fs_1.readFileSync)(urlsFile, 'utf-8');
+    return urlsFromFile
+        .split('\n')
+        .filter((url) => url.trim().length > 0)
+        .map((url) => addProtocolIfMissing(url).trim());
+}
+function filterDuplicates(urls) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const url of urls) {
+        if (seen.has(url)) {
+            duplicates.add(url);
+        }
+        else {
+            seen.add(url);
+        }
+    }
+    return {
+        filteredUrls: Array.from(seen),
+        duplicates: Array.from(duplicates),
+    };
+}
+exports.default = commandCapture;

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

@@ -0,0 +1,61 @@
+"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 commandUtLink = (0, utils_1.newCommand)('link', texts_1.DESC_COMMAND_UT_LINK);
+commandUtLink.option('-w, --workspace <workspace>', texts_1.OPTION_REST_API_WORKSPACE);
+commandUtLink.option('-p, --project <project>', texts_1.OPTION_REST_API_PROJECT);
+commandUtLink.option('-s, --suite <suite>', texts_1.OPTION_SUITE_IDENTIFIER);
+commandUtLink.action(async (options) => {
+    const Input = require('../../../input').default;
+    const ProjectCfg = require('../../../project/cfg').default;
+    output_1.default.handleSignals();
+    const workspace = Input.restApiWorkspace(options.workspace);
+    const project = Input.restApiProject(options.project);
+    const client = Input.restApiTokenClient(false, options.api, options.region);
+    let suiteIdentifier = options.suite;
+    if (!suiteIdentifier) {
+        const opt = await output_1.default.inputMenuAdv(texts_1.TXT_COMMAND_SUITE_SELECT, [
+            {
+                name: texts_1.TXT_COMMAND_SUITE_CREATE_NEW,
+                description: texts_1.TXT_COMMAND_SUITE_CREATE_NEW_UT_DESC,
+                value: 'new',
+            },
+            {
+                name: texts_1.TXT_COMMAND_SUITE_LINK_EXISTING,
+                description: texts_1.TXT_COMMAND_SUITE_LINK_EXISTING_DESC,
+                value: 'existing',
+            },
+        ]);
+        if (opt === 'new') {
+            const name = await output_1.default.inputString(texts_1.TXT_COMMAND_SUITE_NAME);
+            const response = await client.createUtSuite(workspace, project, { name, identifier: name });
+            output_1.default.okSign();
+            output_1.default.normal(texts_1.TXT_COMMAND_SUITE_CREATED);
+            suiteIdentifier = response.identifier;
+        }
+        else {
+            const result = await client.getUtSuites(workspace, project);
+            const suites = result?.suites || [];
+            if (!suites.length) {
+                output_1.default.exitError(texts_1.ERR_NO_UT_SUITES);
+            }
+            if (suites.length === 1) {
+                suiteIdentifier = suites[0].identifier;
+            }
+            else {
+                const items = suites.map((s) => s.name || s.identifier);
+                const index = await output_1.default.inputMenu(texts_1.TXT_COMMAND_UT_LINK_SELECT, items);
+                suiteIdentifier = suites[index].identifier;
+            }
+        }
+    }
+    ProjectCfg.setSuite((0, utils_1.getWorkingDir)(), 'ut', suiteIdentifier);
+    output_1.default.okSign();
+    output_1.default.exitSuccess(texts_1.TXT_COMMAND_UT_LINK_SUCCESS);
+});
+exports.default = commandUtLink;

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

@@ -0,0 +1,91 @@
+"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 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');
+    const { createUtContext, applyUtToken, applyUtCiInfo } = require('../../../unitTest/context');
+    const Input = require('../../../input').default;
+    const ctx = createUtContext();
+    const token = await Input.utSuiteToken();
+    if (!token) {
+        output_1.default.exitError(texts_1.ERR_MISSING_UT_TOKEN);
+    }
+    applyUtToken(ctx, token);
+    const { glob, dryRun } = validateInputAndOptions(input, options);
+    const ciInfo = await getCiInfo();
+    applyUtCiInfo(ctx, ciInfo);
+    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(ctx, files);
+    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,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 upload_1 = __importDefault(require("./unit/upload"));
+const link_1 = __importDefault(require("./unit/link"));
+const commandUnit = (0, utils_1.newCommand)('unit', texts_1.DESC_COMMAND_UNIT);
+commandUnit.addCommand(upload_1.default);
+commandUnit.addCommand(link_1.default);
+exports.default = commandUnit;

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

@@ -0,0 +1,61 @@
+"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 commandVisualLink = (0, utils_1.newCommand)('link', texts_1.DESC_COMMAND_VT_LINK);
+commandVisualLink.option('-w, --workspace <workspace>', texts_1.OPTION_REST_API_WORKSPACE);
+commandVisualLink.option('-p, --project <project>', texts_1.OPTION_REST_API_PROJECT);
+commandVisualLink.option('-s, --suite <suite>', texts_1.OPTION_SUITE_IDENTIFIER);
+commandVisualLink.action(async (options) => {
+    const Input = require('../../../input').default;
+    const ProjectCfg = require('../../../project/cfg').default;
+    output_1.default.handleSignals();
+    const workspace = Input.restApiWorkspace(options.workspace);
+    const project = Input.restApiProject(options.project);
+    const client = Input.restApiTokenClient(false, options.api, options.region);
+    let suiteIdentifier = options.suite;
+    if (!suiteIdentifier) {
+        const opt = await output_1.default.inputMenuAdv(texts_1.TXT_COMMAND_SUITE_SELECT, [
+            {
+                name: texts_1.TXT_COMMAND_SUITE_CREATE_NEW,
+                description: texts_1.TXT_COMMAND_SUITE_CREATE_NEW_VT_DESC,
+                value: 'new',
+            },
+            {
+                name: texts_1.TXT_COMMAND_SUITE_LINK_EXISTING,
+                description: texts_1.TXT_COMMAND_SUITE_LINK_EXISTING_DESC,
+                value: 'existing',
+            },
+        ]);
+        if (opt === 'new') {
+            const name = await output_1.default.inputString(texts_1.TXT_COMMAND_SUITE_NAME);
+            const response = await client.createVtSuite(workspace, project, { name, identifier: name });
+            output_1.default.okSign();
+            output_1.default.normal(texts_1.TXT_COMMAND_SUITE_CREATED);
+            suiteIdentifier = response.identifier;
+        }
+        else {
+            const result = await client.getVtSuites(workspace, project);
+            const suites = result?.suites || [];
+            if (!suites.length) {
+                output_1.default.exitError(texts_1.ERR_NO_VT_SUITES);
+            }
+            if (suites.length === 1) {
+                suiteIdentifier = suites[0].identifier;
+            }
+            else {
+                const items = suites.map((s) => s.name || s.identifier);
+                const index = await output_1.default.inputMenu(texts_1.TXT_COMMAND_VT_LINK_SELECT, items);
+                suiteIdentifier = suites[index].identifier;
+            }
+        }
+    }
+    ProjectCfg.setSuite((0, utils_1.getWorkingDir)(), 'vt', suiteIdentifier);
+    output_1.default.okSign();
+    output_1.default.exitSuccess(texts_1.TXT_COMMAND_VT_LINK_SUCCESS);
+});
+exports.default = commandVisualLink;

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

@@ -0,0 +1,32 @@
+"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 } = require('../../../../visualTest/validation');
+    const { closeSession } = require('../../../../visualTest/requests');
+    const { createVtContext, applyToken } = require('../../../../visualTest/context');
+    const Input = require('../../../../input').default;
+    const token = await Input.vtSuiteToken();
+    if (!token) {
+        output_1.default.exitError(texts_1.ERR_MISSING_VT_TOKEN);
+    }
+    if (!checkBuildId()) {
+        output_1.default.exitError(texts_1.ERR_MISSING_BUILD_ID);
+    }
+    const ctx = createVtContext();
+    applyToken(ctx, token);
+    try {
+        const { message } = await closeSession(ctx);
+        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,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 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 } = require('../../../../visualTest/validation');
+    const { getDefaultSettings } = require('../../../../visualTest/requests');
+    const { debug, createVtContext, applyExecOptions, applyCiAndCommitInfo, applyToken } = 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');
+    const Input = require('../../../../input').default;
+    const ctx = createVtContext();
+    applyExecOptions(ctx, options);
+    try {
+        const browserPath = await getBrowserPath();
+        ctx.browserPath = browserPath;
+    }
+    catch (error) {
+        output_1.default.exitError(`${error}`);
+    }
+    const token = await Input.vtSuiteToken();
+    if (!token) {
+        output_1.default.exitError(texts_1.ERR_MISSING_VT_TOKEN);
+    }
+    applyToken(ctx, token);
+    if (!checkParallel(ctx)) {
+        output_1.default.exitError(texts_1.ERR_MISSING_BUILD_ID);
+    }
+    const app = await createServer(ctx);
+    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(ctx);
+        setDefaultSettings(defaultSettings);
+        const ciAndGitInfo = await getCiAndGitInfo({
+            baseBranch: defaultSettings.baseBranch,
+            logger: output_1.default.warning,
+        });
+        applyCiAndCommitInfo(ctx, 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(ctx, 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,145 @@
+"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.delaySchema = 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.delaySchema = zod_1.z
+    .array(zod_1.z.string().regex(/^(?:([^:]+)::)?(\d+)$/, {
+    message: "Delay option must follow pattern '[scope::]milliseconds' (scope is optional)",
+}))
+    .optional()
+    .transform((value) => value?.map((v) => {
+    let scope = exports.DEFAULT_SCOPE;
+    let milliseconds;
+    if (v.includes('::')) {
+        const [scopePart, msPart] = v.split('::');
+        scope = scopePart.trim();
+        milliseconds = Number(msPart);
+    }
+    else {
+        milliseconds = Number(v);
+    }
+    if (milliseconds < 1 || milliseconds > 60000) {
+        throw new zod_1.z.ZodError([
+            {
+                code: 'custom',
+                message: 'Delay must be between 1 and 60000 milliseconds',
+                path: [],
+            },
+        ]);
+    }
+    return { scope, value: milliseconds };
+}));
+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);