@playq/core 0.2.77

package/dist/helper/bundle/defaultEntries.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = [
+    // baseUrl
+    {
+        "name": "config.baseUrl",
+        "value": "https://your-app.com",
+        "description": "Base URL for the application",
+    },
+    // cucumber
+    {
+        "name": "config.cucumber.featureFileCache",
+        "value": "false",
+        "description": "Cache feature files for faster execution",
+    },
+    {
+        "name": "config.cucumber.stepGroupCache",
+        "value": "true",
+        "description": "Cache step groups during execution",
+    },
+    // browser
+    {
+        "name": "config.browser.playwrightSession",
+        "value": "shared",
+        "description": "Playwright browser session control",
+    },
+    {
+        "name": "config.browser.cucumberSession",
+        "value": "perScenario",
+        "description": "Cucumber browser session control",
+    },
+    {
+        "name": "config.browser.headless",
+        "value": "true",
+        "description": "Run browser in headless mode",
+    },
+    {
+        "name": "config.browser.browserType",
+        "value": "chromium",
+        "description": "Browser type: chromium, firefox or webkit",
+    },
+    // artifacts
+    {
+        "name": "config.artifacts.screenshot",
+        "value": "true",
+        "description": "Capture screenshots",
+    },
+    {
+        "name": "config.artifacts.video",
+        "value": "true",
+        "description": "Capture videos",
+    },
+    {
+        "name": "config.artifacts.trace",
+        "value": "true",
+        "description": "Capture Playwright traces",
+    },
+    {
+        "name": "config.artifacts.onFailureOnly",
+        "value": "true",
+        "description": "Capture artifacts only on failure",
+    },
+    {
+        "name": "config.artifacts.onSuccessOnly",
+        "value": "false",
+        "description": "Capture artifacts only on success",
+    },
+    {
+        "name": "config.artifacts.cleanUpBeforeRun",
+        "value": "true",
+        "description": "Clean up artifacts before run",
+    },
+    // testExecution
+    {
+        "name": "config.testExecution.timeout",
+        "value": "80000",
+        "description": "Test execution timeout",
+    },
+    {
+        "name": "config.testExecution.actionTimeout",
+        "value": "10000",
+        "description": "Action timeout in milliseconds",
+    },
+    {
+        "name": "config.testExecution.navigationTimeout",
+        "value": "20000",
+        "description": "Navigation timeout in milliseconds",
+    },
+    {
+        "name": "config.testExecution.retryOnFailure",
+        "value": "true",
+        "description": "Retry tests on failure",
+    },
+    {
+        "name": "config.testExecution.parallel",
+        "value": "true",
+        "description": "Run tests in parallel",
+    },
+    {
+        "name": "config.testExecution.maxInstances",
+        "value": "5",
+        "description": "Maximum parallel test instances",
+    },
+    {
+        "name": "config.testExecution.maxRetries",
+        "value": "2",
+        "description": "Maximum number of retries",
+    },
+    {
+        "name": "config.testExecution.retryDelay",
+        "value": "1000",
+        "description": "Delay between retries in milliseconds",
+    },
+    {
+        "name": "config.testExecution.retryInterval",
+        "value": "2000",
+        "description": "Interval between retries in milliseconds",
+    },
+    {
+        "name": "config.testExecution.retryTimeout",
+        "value": "30000",
+        "description": "Total retry timeout in milliseconds",
+    },
+    {
+        "name": "config.testExecution.order",
+        "value": "sequential",
+        "description": "Test execution order",
+    },
+    // apiTest
+    {
+        "name": "config.apiTest.maxUrlRedirects",
+        "value": "5",
+        "description": "Maximum number of URL redirects",
+    },
+    {
+        "name": "config.apiTest.timeout",
+        "value": "10000",
+        "description": "API request timeout in milliseconds",
+    },
+    // patternIq
+    {
+        "name": "config.patternIq.enable",
+        "value": "false",
+        "description": "Enable PatternIQ",
+    },
+    {
+        "name": "config.patternIq.config",
+        "value": "default",
+        "description": "PatternIQ configuration source",
+    },
+    {
+        "name": "config.patternIq.retryInterval",
+        "value": "2000",
+        "description": "PatternIQ retry interval in milliseconds",
+    },
+    {
+        "name": "config.patternIq.retryTimeout",
+        "value": "30000",
+        "description": "PatternIQ total retry timeout in milliseconds",
+    },
+    // smartAi
+    {
+        "name": "config.smartAi.enable",
+        "value": "false",
+        "description": "Enable SmartAI",
+    },
+    {
+        "name": "config.smartAi.consoleLog",
+        "value": "true",
+        "description": "Log SmartAI actions to console",
+    },
+    {
+        "name": "config.smartAi.resolve",
+        "value": "smart",
+        "description": "SmartAI resolution mode",
+    },
+    // report
+    {
+        "name": "report.allure.singleFile",
+        "value": "false",
+        "description": "Enable Allure single file report",
+    },
+    // featureFlags
+    {
+        "name": "config.featureFlags.enableBetaUI",
+        "value": "true",
+        "description": "Enable Beta UI",
+    },
+    {
+        "name": "config.featureFlags.useMockBackend",
+        "value": "false",
+        "description": "Use mock backend",
+    },
+    // supportedLanguages
+    {
+        "name": "config.supportedLanguages",
+        "value": "en,fr,es",
+        "description": "Supported languages",
+    },
+];

package/dist/helper/bundle/env.d.ts

@@ -0,0 +1 @@
+export declare const loadEnv: (env?: string) => void;

package/dist/helper/bundle/env.js

@@ -0,0 +1,157 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEnv = void 0;
+const dotenv = __importStar(require("dotenv"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const loadEnv = (env) => {
+    // Setting PlayQ Project Root
+    if (!process.env['PLAYQ_PROJECT_ROOT']) {
+        process.env['PLAYQ_PROJECT_ROOT'] = findProjectRoot();
+    }
+    // Setting PlayQ Core Root
+    process.env['PLAYQ_CORE_ROOT'] = path.resolve(process.env['PLAYQ_PROJECT_ROOT'], 'src');
+    // Setting PlayQ Defaults
+    if (!process.env.PLAYQ_REPORT_OPEN)
+        process.env.PLAYQ_REPORT_OPEN = 'true';
+    // Setting PlayQ Runner
+    if (process.env.PLAYQ_RUNNER && ['bdd', 'cuke', 'cucumber'].includes(process.env.PLAYQ_RUNNER.trim())) {
+        process.env.PLAYQ_RUNNER = 'cucumber';
+    }
+    else {
+        process.env.PLAYQ_RUNNER = 'playwright';
+    }
+    let envPath;
+    let playqEnvMem = undefined;
+    let playqRunnerMem = process.env['PLAYQ_RUNNER'];
+    if (process.env['PLAYQ_ENV'])
+        playqEnvMem = process.env['PLAYQ_ENV'];
+    if (env) {
+        envPath = path.resolve(process.env.PLAYQ_PROJECT_ROOT, 'environments', `${env}.env`);
+        dotenv.config({
+            override: true,
+            path: envPath
+        });
+    }
+    else {
+        if (process.env.PLAYQ_ENV) {
+            process.env.PLAYQ_ENV = process.env.PLAYQ_ENV.trim();
+            envPath = path.resolve(process.env.PLAYQ_PROJECT_ROOT, 'environments', `${process.env.PLAYQ_ENV}.env`);
+            dotenv.config({
+                override: true,
+                path: envPath
+            });
+        }
+        else {
+            // No explicit env passed. Try to load 'default.env' if it exists.
+            // Try several candidate roots to locate default.env. In some cases
+            // PLAYQ_PROJECT_ROOT or process.cwd() may differ depending on how
+            // Playwright/VSCode started the process, so check a few locations.
+            const candidateRoots = [process.env.PLAYQ_PROJECT_ROOT, process.cwd(), findProjectRoot()];
+            let loadedDefault = false;
+            for (const root of candidateRoots) {
+                if (!root)
+                    continue;
+                const candidatePath = path.resolve(root, 'environments', 'default.env');
+                if (fs.existsSync(candidatePath)) {
+                    dotenv.config({ override: true, path: candidatePath });
+                    process.env.PLAYQ_ENV = 'default';
+                    console.log(`ℹ️ Loaded default environment from ${candidatePath}`);
+                    loadedDefault = true;
+                    break;
+                }
+            }
+            if (!loadedDefault) {
+                // As a last attempt, try walking up from this file's directory to find an 'environments' folder
+                let cur = __dirname;
+                for (let i = 0; i < 6 && !loadedDefault; i++) {
+                    const candidatePath = path.resolve(cur, '..'.repeat(i), 'environments', 'default.env');
+                    if (fs.existsSync(candidatePath)) {
+                        dotenv.config({ override: true, path: candidatePath });
+                        process.env.PLAYQ_ENV = 'default';
+                        console.log(`ℹ️ Loaded default environment from ${candidatePath}`);
+                        loadedDefault = true;
+                        break;
+                    }
+                }
+            }
+            if (!loadedDefault) {
+                console.warn("NO ENVIRONMENTS PASSED : default.env not present or --env is undefined!");
+            }
+        }
+    }
+    process.env['PLAYQ_RUNNER'] = playqRunnerMem; // Override any environment config for PLAYQ_RUNNER.
+    if (playqEnvMem)
+        process.env['PLAYQ_ENV'] = playqEnvMem;
+    // Load variables only when not explicitly disabled and TS loader is present (parent process may not have ts-node)
+    try {
+        if (process.env.PLAYQ_NO_INIT_VARS === '1') {
+            // Parent runner explicitly disables var init; child will handle it.
+        }
+        else {
+            const canRequireTs = !!require.extensions['.ts'];
+            if (!canRequireTs) {
+                // Defer var loading to the test subprocess (Playwright/Cucumber), which preloads ts-node.
+            }
+            else {
+                const { initVars } = require('./vars');
+                if (typeof initVars === 'function') {
+                    initVars();
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn('Warning: Could not initialize vars:', error.message);
+    }
+};
+exports.loadEnv = loadEnv;
+function findProjectRoot() {
+    // Method 1: Check for environment variable
+    if (process.env.PLAYQ_PROJECT_ROOT) {
+        return process.env.PLAYQ_PROJECT_ROOT;
+    }
+    // Method 2: Walk up from cwd to find package.json
+    let currentDir = process.cwd();
+    while (currentDir !== path.dirname(currentDir)) {
+        if (fs.existsSync(path.join(currentDir, 'package.json'))) {
+            return currentDir;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    // Method 3: Fallback to cwd
+    return process.cwd();
+}

package/dist/helper/bundle/vars.d.ts

@@ -0,0 +1,9 @@
+declare function getValue(key: string, ifEmpty?: boolean): string;
+declare function getConfigValue(key: string, ifEmpty?: boolean): string;
+declare function setValue(key: string, value: string): void;
+declare function replaceVariables(input: any): string;
+declare function debugVars(): void;
+declare function loadFileEntries(file: string, constName: string, prefix?: string): void;
+declare function parseLooseJson(str: string): Record<string, any>;
+declare function initVars(vars?: Record<string, string>): void;
+export { getValue, getConfigValue, setValue, replaceVariables, debugVars, parseLooseJson, loadFileEntries, initVars };