bdy 1.18.24-dev → 1.18.24-dev-pipeline

package/distTs/src/command/project/link.js

@@ -23,7 +23,7 @@ commandProjectLink.action(async (dir, options) => {
     ProjectCfg.init(path, workspace, project);
     output_1.default.okSign();
     output_1.default.normal(texts_1.TXT_COMMAND_PROJECT_LINK_TO, false);
-    output_1.default.light(` ${url}`);
+    output_1.default.cyan(` ${url}`);
     await initRepo(workspace, project, path, git, options);
     tryNow();
     output_1.default.exitNormal();
@@ -54,13 +54,13 @@ const tryNow = () => {
     output_1.default.arrowSign();
     output_1.default.label(texts_1.OPT_COMMAND_PROJECT_LINK_TRY_NOW);
     output_1.default.dim('$ ', false);
-    output_1.default.light('bdy tunnel http 3000 ', false);
+    output_1.default.cyan('bdy tunnel http 3000 ', false);
     output_1.default.muted('                  Expose localhost:3000 to the internet');
     output_1.default.dim('$ ', false);
-    output_1.default.light('bdy package publish . ', false);
+    output_1.default.cyan('bdy package publish . ', false);
     output_1.default.muted('                 Publish a package from the current project');
     output_1.default.dim('$ ', false);
-    output_1.default.light('bdy sandbox create --run "npm start" ', false);
+    output_1.default.cyan('bdy sandbox create --run "npm start" ', false);
     output_1.default.muted('  Spin up a cloud sandbox and run your app');
 };
 const initRepo = async (workspace, project, path, git, options) => {
@@ -89,16 +89,16 @@ const initRepo = async (workspace, project, path, git, options) => {
         });
         output_1.default.okSign();
         output_1.default.normal('Remote ', false);
-        output_1.default.light('origin ', false);
+        output_1.default.cyan('origin ', false);
         output_1.default.normal('set to ', false);
-        output_1.default.light(remote);
+        output_1.default.cyan(remote);
     }
     else if (remotes.origin !== remote) {
         output_1.default.yellow(texts_1.OPT_COMMAND_PROJECT_LINK_HAS_REMOTE);
         output_1.default.normal('Current origin: ', false);
-        output_1.default.light(remotes.origin);
+        output_1.default.cyan(remotes.origin);
         output_1.default.normal('Buddy project: ', false);
-        output_1.default.light(remote);
+        output_1.default.cyan(remote);
         const opt = await output_1.default.inputMenuAdv(texts_1.OPT_COMMAND_PROJECT_LINK_SET_GIT_REMOTE, [
             {
                 name: 'Add buddy remote',
@@ -127,9 +127,9 @@ const initRepo = async (workspace, project, path, git, options) => {
             });
             output_1.default.okSign();
             output_1.default.normal('Remote ', false);
-            output_1.default.light('buddy ', false);
+            output_1.default.cyan('buddy ', false);
             output_1.default.normal('set to ', false);
-            output_1.default.light(remote);
+            output_1.default.cyan(remote);
         }
         else if (opt === 'origin') {
             await (0, utils_1.execLocally)(`git remote rm origin`, {
@@ -140,7 +140,7 @@ const initRepo = async (workspace, project, path, git, options) => {
             });
             output_1.default.okSign();
             output_1.default.normal('Origin replaced with ', false);
-            output_1.default.light(remote);
+            output_1.default.cyan(remote);
         }
         else {
             return;

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

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOptions = validateOptions;
+exports.checkIfMinimalOptionsAreProvided = checkIfMinimalOptionsAreProvided;
+const zod_1 = require("zod");
+const output_1 = __importDefault(require("../../../output"));
+const validation_1 = require("../visual/shared/validation");
+const optionsSchema = zod_1.z.object({
+    urls: zod_1.z.string().optional(),
+    sitemap: zod_1.z.string().optional(),
+    urlsFile: zod_1.z.string().optional(),
+    follow: zod_1.z.boolean(),
+    respectRobots: zod_1.z.boolean(),
+    ignore: zod_1.z
+        .array(zod_1.z.string().regex(/^(?:([^:]+)::)?(?:(CSS|XPATH))=(.+)$/, {
+        message: "Ignore option must follow pattern '[scope::]type=value' where type must be CSS or XPATH (scope is optional)",
+    }))
+        .optional()
+        .transform(validation_1.parseScopedSelector),
+    cookie: validation_1.cookieSchema,
+    header: validation_1.headerSchema,
+    delay: 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) => {
+        if (v.includes('::')) {
+            const [scope, milliseconds] = v.split('::');
+            return { scope: scope.trim(), value: Number(milliseconds) };
+        }
+        else {
+            return { scope: validation_1.DEFAULT_SCOPE, value: Number(v) };
+        }
+    })),
+    waitFor: validation_1.waitForSchema,
+    ignoreUrls: zod_1.z.array(zod_1.z.string()).optional(),
+    dryRun: zod_1.z.boolean().optional(),
+});
+function validateOptions(options) {
+    try {
+        const validatedOptions = optionsSchema.parse(options);
+        return validatedOptions;
+    }
+    catch (error) {
+        if (error instanceof zod_1.ZodError) {
+            output_1.default.exitError(error.errors.map((e) => e.message).join(', '));
+        }
+        else {
+            throw error;
+        }
+    }
+}
+function checkIfMinimalOptionsAreProvided(options) {
+    return !!options.urls || !!options.sitemap || !!options.urlsFile;
+}

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

@@ -0,0 +1,100 @@
+"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 { checkToken } = require('../../visualTest/validation');
+    const { addProtocolIfMissing } = require('../../visualTest/linkUtils');
+    const { sendCompareLinks } = require('../../visualTest/requests');
+    const { checkIfMinimalOptionsAreProvided, validateOptions } = require('./capture/validation');
+    const { setCiAndCommitInfo } = require('../../visualTest/context');
+    const validatedOptions = validateOptions(options);
+    if (!checkToken('vt')) {
+        output_1.default.exitError(texts_1.ERR_MISSING_VT_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));
+    setCiAndCommitInfo(ciAndGitInfo);
+    try {
+        const { message } = await sendCompareLinks(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/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);