@empiricalrun/playwright-utils 0.22.7 → 0.23.0

package/bundled/test-gen/bin/utils/platform/web/index.js

@@ -0,0 +1,544 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSyntaxValid = exports.getVariableDeclarationsFromCode = exports.buildTestNamePrompt = exports.isTestPresent = exports.appendScopeToCreateTest = exports.addUserContextFixture = exports.importAllExportsStmtFromFilePaths = exports.injectCodeSnippetBySuiteChain = exports.replaceCreateTestWithNewCode = exports.getPageVariableNameFromCreateTest = exports.getFixtureImportPath = exports.removeTestOnly = exports.addNewImport = exports.formatCode = exports.lintErrors = exports.stripAndPrependImports = exports.validateTypescript = exports.appendToTestBlock = exports.findFirstSerialDescribeBlock = exports.hasTopLevelDescribeConfigureWithSerialMode = exports.getTypescriptTestBlock = exports.getTestModuleAliasFromSourceFile = void 0;
+const parser_1 = require("@babel/parser");
+const eslint_1 = require("eslint");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
+const path_1 = __importDefault(require("path"));
+const prettier_1 = __importDefault(require("prettier"));
+const ts_morph_1 = require("ts-morph");
+const typescript_1 = __importDefault(require("typescript"));
+const getTestModuleAliasFromSourceFile = (sourceFile) => {
+    return (sourceFile
+        .getImportDeclarations()
+        // Look for any import that includes "test" as a named import, regardless of module path
+        // "test" can be imported from "@playwright/test" or "<some-fixture>"
+        .find((importDecl) => importDecl
+        .getNamedImports()
+        .some((namedImport) => namedImport.getName() === "test"))
+        ?.getNamedImports()
+        .find((namedImport) => namedImport.getName() === "test")
+        ?.getAliasNode()
+        ?.getText() || "test");
+};
+exports.getTestModuleAliasFromSourceFile = getTestModuleAliasFromSourceFile;
+/**
+ * function to get the test block and test node for the scenario
+ * @export
+ * @param {string} scenarioName
+ * @param {string} content
+ * @return { testBlock: string; parentDescribe: string; } testBlock - the test block content, testNode - the test function node
+ */
+function getTypescriptTestBlock({ scenarioName, suites, content, }) {
+    const project = new ts_morph_1.Project();
+    const sourceFile = project.createSourceFile("test.ts", content);
+    const testAlias = (0, exports.getTestModuleAliasFromSourceFile)(sourceFile);
+    // Get all test function nodes that match the scenario name
+    const matchingTestFunctionNodes = sourceFile
+        .getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
+        .filter((node) => {
+        return Boolean(node.getExpression().getText() === testAlias &&
+            node.getArguments()[0]?.getText().includes(scenarioName));
+    });
+    if (!suites?.length) {
+        const firstNode = matchingTestFunctionNodes?.[0];
+        return {
+            testBlock: firstNode?.getText(),
+            testNode: firstNode,
+            testAlias,
+        };
+    }
+    // Iterate over each test function node and check if the suites match
+    for (const testNode of matchingTestFunctionNodes) {
+        const parentDescribes = getParentDescribeNames(testNode);
+        if ((0, lodash_isequal_1.default)(parentDescribes, suites)) {
+            // Found the matching test block
+            return {
+                testBlock: testNode.getText(),
+                testNode,
+                testAlias,
+            };
+        }
+    }
+    // No matching test block found
+    return {
+        testBlock: undefined,
+        testNode: undefined,
+        testAlias,
+    };
+}
+exports.getTypescriptTestBlock = getTypescriptTestBlock;
+// get the names of parent describe blocks
+function getParentDescribeNames(node) {
+    const names = [];
+    let current = node.getParent();
+    while (current) {
+        if (ts_morph_1.Node.isCallExpression(current)) {
+            const expr = current.getExpression();
+            if (expr.getText() === "test.describe") {
+                const describeBlockArguments = current.getArguments();
+                if (describeBlockArguments.length > 0) {
+                    const describeBlockName = describeBlockArguments[0];
+                    if (ts_morph_1.Node.isStringLiteral(describeBlockName)) {
+                        names.push(describeBlockName.getLiteralText());
+                    }
+                }
+            }
+        }
+        current = current.getParent();
+    }
+    return names.reverse(); // Reverse to get from outermost to innermost
+}
+async function hasTopLevelDescribeConfigureWithSerialMode(filePath) {
+    const project = new ts_morph_1.Project();
+    const content = await fs_extra_1.default.readFile(filePath, "utf-8");
+    const sourceFile = project.createSourceFile("test.ts", content);
+    const statements = sourceFile.getStatements();
+    for (const statement of statements) {
+        // Check if the statement is an expression statement
+        if (statement.getKind() === ts_morph_1.SyntaxKind.ExpressionStatement) {
+            const expression = statement.getFirstChildByKind(ts_morph_1.SyntaxKind.CallExpression);
+            if (expression) {
+                const expressionText = expression.getExpression().getText();
+                // Check if it's `test.describe.configure`
+                if (expressionText === "test.describe.configure") {
+                    // Check if arguments exist and if the first argument is an object literal with mode serial
+                    const args = expression.getArguments();
+                    const firstArgText = args[0]?.getText();
+                    if (firstArgText &&
+                        firstArgText.includes("serial") &&
+                        firstArgText.includes("mode")) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+exports.hasTopLevelDescribeConfigureWithSerialMode = hasTopLevelDescribeConfigureWithSerialMode;
+/**
+ * Function to find the first 'describe' block configured with 'serial: true'
+ *
+ * e.g.
+ *
+ * test.describe("foo", () => {
+ *
+ *    test.describe.configure({ mode: "serial" });
+ *
+ *    test.describe("bar", () => {
+ *
+ *      test.describe.configure({ mode: "serial" });
+ *
+ *    })
+ *
+ * })
+ *
+ * for the above example,
+ * this function will return the first 'describe' block which is named "foo"
+ *
+ * @param {(Node | undefined)} node
+ * @return {(Node | undefined)}
+ */
+function findFirstSerialDescribeBlock(node) {
+    let currentNode = node;
+    // Traverse upwards until we find a 'describe' block with 'serial: true'
+    while (currentNode) {
+        const parentDescribe = currentNode.getFirstAncestorByKind(ts_morph_1.SyntaxKind.CallExpression);
+        if (parentDescribe) {
+            const isDescribe = parentDescribe.getFirstChild()?.getText() === "test.describe";
+            if (isDescribe) {
+                const configureCall = parentDescribe
+                    .getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
+                    .find((call) => call.getText().includes("configure"));
+                if (configureCall) {
+                    // Check if 'serial: true' exists
+                    if (configureCall.getText().includes("serial")) {
+                        return parentDescribe;
+                    }
+                }
+            }
+        }
+        currentNode = parentDescribe; // Move up the tree
+    }
+    return undefined; // Return undefined if no 'describe' with serial: true is found
+}
+exports.findFirstSerialDescribeBlock = findFirstSerialDescribeBlock;
+function appendToTestBlock(testBlock, content) {
+    const updateTestBlock = testBlock.replace(/\}\)$/, `\n\n${content}\n\n })`);
+    return updateTestBlock;
+}
+exports.appendToTestBlock = appendToTestBlock;
+function validateTypescript(filePath) {
+    // Create a compiler host to read files
+    const compilerHost = typescript_1.default.createCompilerHost({});
+    compilerHost.readFile = (file) => fs_extra_1.default.readFileSync(file, "utf8");
+    // Create a program with a single source file
+    const program = typescript_1.default.createProgram([filePath], {
+        esModuleInterop: true,
+        allowSyntheticDefaultImports: true,
+    }, compilerHost);
+    // Get the source file
+    const sourceFile = program.getSourceFile(filePath);
+    // Get and report any syntactic errors
+    const errors = [];
+    const syntacticDiagnostics = program.getSyntacticDiagnostics(sourceFile);
+    if (syntacticDiagnostics.length > 0) {
+        syntacticDiagnostics.forEach((diagnostic) => {
+            if (typeof diagnostic.messageText === "string") {
+                errors.push(diagnostic.messageText);
+            }
+        });
+    }
+    // Get and report any semantic errors
+    const semanticDiagnostics = program.getSemanticDiagnostics(sourceFile);
+    if (semanticDiagnostics.length > 0) {
+        semanticDiagnostics.forEach((diagnostic) => {
+            if (typeof diagnostic.messageText === "string") {
+                errors.push(diagnostic.messageText);
+            }
+            else {
+                let messageChain = diagnostic.messageText;
+                errors.push(messageChain.messageText);
+                while (messageChain?.next) {
+                    messageChain = messageChain.next[0];
+                    errors.push(messageChain?.messageText);
+                }
+            }
+        });
+    }
+    return errors;
+}
+exports.validateTypescript = validateTypescript;
+async function stripAndPrependImports(content, testName) {
+    const importRegexp = /import\s+\{[^}]*\}\s+from\s+["'][^"']+["'];?/g;
+    const imports = content.match(importRegexp);
+    const { testBlock: strippedContent } = getTypescriptTestBlock({
+        scenarioName: testName,
+        content,
+        suites: [], // since this method is called on the generated content, not the whole file
+    });
+    const prependContent = (imports?.join("\n") || "") + "\n\n";
+    return [prependContent, strippedContent];
+}
+exports.stripAndPrependImports = stripAndPrependImports;
+async function lintErrors(filePath) {
+    const eslint = new eslint_1.ESLint({
+        fix: true,
+        useEslintrc: true,
+    });
+    const [result] = await eslint.lintFiles(filePath);
+    if (result?.output) {
+        await fs_extra_1.default.writeFile(filePath, result.output);
+    }
+}
+exports.lintErrors = lintErrors;
+async function formatCode(filePath, trace) {
+    const fileContent = fs_extra_1.default.readFileSync(filePath, "utf8");
+    if (!fileContent) {
+        trace?.span({
+            name: "prettier-format-output",
+            output: `${filePath} file is empty`,
+        });
+        return;
+    }
+    const prettierConfig = {};
+    const formattedContent = await prettier_1.default.format(fileContent, {
+        ...prettierConfig,
+        filepath: filePath,
+    });
+    trace?.span({ name: "prettier-format-output", output: formattedContent });
+    await fs_extra_1.default.writeFile(filePath, formattedContent);
+}
+exports.formatCode = formatCode;
+function addNewImport(contents, modules, pkg) {
+    return `import { ${modules.join(", ")} } from "${pkg}";\n${contents}`;
+}
+exports.addNewImport = addNewImport;
+async function removeTestOnly(filePath) {
+    const contents = await fs_extra_1.default.readFile(filePath, "utf8");
+    const updatedContent = contents
+        .replace("test.only(", "test(")
+        .replace("test.describe.only(", "test.describe(");
+    return fs_extra_1.default.writeFile(filePath, updatedContent);
+}
+exports.removeTestOnly = removeTestOnly;
+function getFixtureImportPath(filePath) {
+    // get the depth from the tests folder
+    // assumption fixtures are always int the folder tests/fixtures
+    const subFolder = filePath.split("/tests/")[1];
+    const subFolderDepth = subFolder?.split("/").length
+        ? subFolder?.split("/").length - 1
+        : 0;
+    // create an array of path segments to the fixtures file
+    const fixturesPath = [
+        "./",
+        subFolderDepth ? new Array(subFolderDepth).fill("../").join("") : "",
+        "fixtures",
+    ].join("");
+    return fixturesPath;
+}
+exports.getFixtureImportPath = getFixtureImportPath;
+async function getPageVariableNameFromCreateTest(filePath) {
+    const contents = await fs_extra_1.default.readFile(filePath, "utf-8");
+    const project = new ts_morph_1.Project();
+    const sourceFile = project.createSourceFile("test.ts", contents);
+    const createTestNode = sourceFile.getFirstDescendant((node) => !!(node.isKind(ts_morph_1.SyntaxKind.CallExpression) &&
+        node.getExpression().getText() === "createTest"));
+    if (!createTestNode) {
+        throw new Error("createTest not found in file");
+    }
+    const descendants = createTestNode?.getDescendants();
+    const descendentTexts = descendants.map((d) => d.getText());
+    const parameterSeparatorIdx = descendentTexts.findIndex((s) => s === ",");
+    const pageVariableName = descendentTexts[parameterSeparatorIdx + 1];
+    // handle cases like "page as Page"
+    return pageVariableName?.split(" ")[0];
+}
+exports.getPageVariableNameFromCreateTest = getPageVariableNameFromCreateTest;
+function resolveImportsFromFixtures({ fixtureImportNode, testAlias, filePath, updatedTestFile, }) {
+    const imports = {};
+    const importClause = fixtureImportNode.getImportClause();
+    if (!importClause) {
+        return updatedTestFile;
+    }
+    const namedImports = importClause.getNamedImports().map((imp) => {
+        // aliasNode is truthy if the import is aliased (e.g. import { test as setup } ...)
+        const aliasNode = imp.getAliasNode();
+        const originalImportName = imp.getName();
+        const aliasImportName = aliasNode?.getText();
+        const importName = aliasImportName || originalImportName;
+        imports[originalImportName] = imp.getText();
+        return importName;
+    });
+    const isComplete = namedImports.includes(testAlias) && namedImports.includes("expect");
+    if (!isComplete) {
+        if (!Object.keys(imports).includes("test")) {
+            imports["test"] = "test";
+        }
+        if (!Object.keys(imports).includes("expect")) {
+            imports["expect"] = "expect";
+        }
+        const expectedImports = `import { ${Object.values(imports).join(", ")} } from "${getFixtureImportPath(filePath)}";`;
+        updatedTestFile = updatedTestFile.replace(fixtureImportNode.getText(), expectedImports);
+    }
+    return updatedTestFile;
+}
+function replaceCreateTestWithNewCode(filePath, contents, generatedCode) {
+    const project = new ts_morph_1.Project();
+    const sourceFile = project.createSourceFile("test.ts", contents);
+    const testAlias = (0, exports.getTestModuleAliasFromSourceFile)(sourceFile);
+    const createTestNode = sourceFile.getFirstDescendant((node) => !!(node.isKind(ts_morph_1.SyntaxKind.CallExpression) &&
+        node.getExpression().getText() === "createTest"));
+    const createTestWithAwait = `await ${createTestNode?.getText()}`;
+    let updatedTestFile = contents.replace(createTestWithAwait, function () {
+        // str.replace treats characters like $ differently
+        // Using a function helps us avoid special handling
+        // https://stackoverflow.com/a/28103073
+        return "\n" + generatedCode;
+    });
+    const fixtureImportNode = sourceFile.getFirstDescendant((node) => !!(node.isKind(ts_morph_1.SyntaxKind.ImportDeclaration) &&
+        node.getText().includes("fixtures")));
+    if (fixtureImportNode) {
+        updatedTestFile = resolveImportsFromFixtures({
+            fixtureImportNode,
+            testAlias,
+            filePath,
+            updatedTestFile,
+        });
+    }
+    return updatedTestFile;
+}
+exports.replaceCreateTestWithNewCode = replaceCreateTestWithNewCode;
+const injectCodeSnippetBySuiteChain = ({ testFileContent, codeSnippet, suites, }) => {
+    const project = new ts_morph_1.Project();
+    // Add the source file content directly into memory
+    const sourceFile = project.createSourceFile("test-file.ts", testFileContent);
+    // Function to insert the test into the appropriate describe block
+    let parentNode = sourceFile;
+    if (!suites.length) {
+        parentNode.addStatements(codeSnippet);
+        return sourceFile.getFullText();
+    }
+    suites.forEach((suiteName, index) => {
+        // Try to find the describe block with the given name
+        let describeBlock = parentNode
+            .getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
+            .find((callExpr) => {
+            const expression = callExpr.getExpression();
+            const firstArg = callExpr?.getArguments()?.[0];
+            return (expression?.getText() === "test.describe" &&
+                firstArg?.getLiteralText() === suiteName);
+        });
+        // If the describe block doesn't exist, create it
+        if (!describeBlock) {
+            const newDescribe = `\n\ntest.describe("${suiteName}", () => {});`;
+            parentNode.addStatements(newDescribe);
+            describeBlock = parentNode
+                .getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
+                .find((callExpr) => {
+                const expression = callExpr.getExpression();
+                const firstArg = callExpr?.getArguments()?.[0];
+                return (expression?.getText() === "test.describe" &&
+                    firstArg?.getLiteralText() === suiteName);
+            });
+        }
+        // If it's the last in the chain, add the test block inside this describe
+        if (index === suites.length - 1) {
+            const block = describeBlock?.getArguments()[1];
+            block.addStatements(codeSnippet);
+        }
+        // Update parentNode to navigate deeper into nested describe blocks
+        parentNode = describeBlock.getArguments()[1];
+    });
+    return sourceFile.getFullText();
+};
+exports.injectCodeSnippetBySuiteChain = injectCodeSnippetBySuiteChain;
+const importAllExportsStmtFromFilePaths = async (repoDir, filePaths, testFilePath) => {
+    const statements = [];
+    for (const filePath of filePaths) {
+        const fullPath = path_1.default.resolve(repoDir, filePath);
+        let importPath = path_1.default.relative(path_1.default.dirname(testFilePath), filePath);
+        if (!importPath.startsWith(".")) {
+            importPath = "./" + importPath;
+        }
+        const file = await fs_extra_1.default.readFile(fullPath, "utf-8");
+        const project = new ts_morph_1.Project();
+        const sourceFile = project.createSourceFile("index.ts", file);
+        const exportedFunctions = sourceFile
+            .getFunctions()
+            .filter((fn) => fn.isExported())
+            .map((fn) => fn.getName());
+        const exportedVariables = sourceFile
+            .getVariableDeclarations()
+            .filter((v) => v.isExported())
+            .map((fn) => fn.getName());
+        const imports = [...exportedFunctions, ...exportedVariables];
+        const importStatement = `import { ${imports.join(",")} } from '${importPath.replace(".ts", "")}';`;
+        statements.push(importStatement);
+    }
+    return statements;
+};
+exports.importAllExportsStmtFromFilePaths = importAllExportsStmtFromFilePaths;
+async function addUserContextFixture({ scenarioName, filePath, suites, }) {
+    // TODO: remove this check when we support user context across repos
+    let fixtureContent = "";
+    try {
+        fixtureContent = await fs_extra_1.default.readFile("./tests/fixtures.ts", "utf-8");
+    }
+    catch (e) {
+        // do nothing
+    }
+    if (!fixtureContent || !fixtureContent.includes("userContext")) {
+        return;
+    }
+    const fileContent = await fs_extra_1.default.readFile(filePath, "utf-8");
+    const { testNode } = getTypescriptTestBlock({
+        scenarioName,
+        content: fileContent,
+        suites,
+    });
+    const currentBlock = testNode?.getText();
+    const arrowFunction = testNode?.getFirstDescendantByKind(ts_morph_1.SyntaxKind.ArrowFunction);
+    if (arrowFunction) {
+        const param = arrowFunction.getParameters()[0]; // Get the first parameter
+        const destructuringParam = param?.getFirstDescendantByKind(ts_morph_1.SyntaxKind.ObjectBindingPattern);
+        if (destructuringParam) {
+            const elements = destructuringParam.getElements();
+            const userContextExists = elements.some((e) => e.getText().includes("userContext"));
+            if (!userContextExists) {
+                const updatedImport = destructuringParam
+                    .getText()
+                    .replace(/\s+/g, "") // Replace all whitespace
+                    .replace(",}", "}") // Remove any trailing commas
+                    .replace("}", ", userContext }");
+                destructuringParam.replaceWithText(updatedImport);
+                await fs_extra_1.default.writeFile(filePath, fileContent.replace(currentBlock, testNode.getText()), "utf-8");
+            }
+        }
+    }
+}
+exports.addUserContextFixture = addUserContextFixture;
+async function appendScopeToCreateTest(filePath, scopeVariables) {
+    const contents = await fs_extra_1.default.readFile(filePath, "utf-8");
+    const project = new ts_morph_1.Project();
+    const sourceFile = project.createSourceFile("test.ts", contents);
+    const createTestNode = sourceFile
+        .getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
+        .find((node) => {
+        const expression = node.getExpression();
+        return expression && expression.getText() === "createTest";
+    });
+    if (!createTestNode) {
+        throw new Error("No createTest call found in the file.");
+    }
+    const args = createTestNode.getArguments();
+    const scopeArgStr = `{ ${scopeVariables.join(", ")} }`;
+    createTestNode.insertArgument(args.length, scopeArgStr);
+    await fs_extra_1.default.writeFile(filePath, sourceFile.getFullText());
+}
+exports.appendScopeToCreateTest = appendScopeToCreateTest;
+function isTestPresent({ specPath, testCase, }) {
+    let isTestPresent = true;
+    isTestPresent = fs_extra_1.default.existsSync(specPath);
+    if (isTestPresent) {
+        const { testBlock } = getTypescriptTestBlock({
+            suites: testCase.suites,
+            scenarioName: testCase.name,
+            content: fs_extra_1.default.readFileSync(specPath, "utf-8"),
+        });
+        isTestPresent = Boolean(testBlock);
+    }
+    return isTestPresent;
+}
+exports.isTestPresent = isTestPresent;
+function buildTestNamePrompt({ testName, suites, }) {
+    return suites?.length
+        ? suites.reduce((text, suite) => {
+            text += `Describe block: ${suite} ----> `;
+            return text;
+        }, "") + testName
+        : testName;
+}
+exports.buildTestNamePrompt = buildTestNamePrompt;
+function getVariableDeclarationsFromCode(sourceCode) {
+    const project = new ts_morph_1.Project();
+    const sourceFile = project.createSourceFile("temp.ts", sourceCode);
+    // Extract variable declarations
+    const variables = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.VariableDeclaration);
+    // Function to extract individual variables from destructured declarations
+    function extractVariables(variable) {
+        const nameNode = variable.getNameNode();
+        if (nameNode.getKind() === ts_morph_1.SyntaxKind.ObjectBindingPattern) {
+            // For object destructuring
+            return nameNode.getElements().map((element) => element.getName());
+        }
+        else if (nameNode.getKind() === ts_morph_1.SyntaxKind.ArrayBindingPattern) {
+            // For array destructuring
+            return nameNode.getElements().map((element) => element.getText());
+        }
+        else {
+            // For regular variable declarations
+            return [variable.getName()];
+        }
+    }
+    // Collect all variable names
+    const allVariables = variables.flatMap((variable) => extractVariables(variable));
+    return allVariables;
+}
+exports.getVariableDeclarationsFromCode = getVariableDeclarationsFromCode;
+function isSyntaxValid(code) {
+    let isSyntaxValid = true;
+    try {
+        (0, parser_1.parse)(code, { sourceType: "module", plugins: ["typescript"] }); // Attempt to parse the code
+    }
+    catch (error) {
+        isSyntaxValid = false;
+    }
+    return isSyntaxValid;
+}
+exports.isSyntaxValid = isSyntaxValid;

package/bundled/test-gen/bin/utils/platform/web/test-files/ts-path-import-validate.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ts-path-import-validate.d.ts.map

package/bundled/test-gen/bin/utils/platform/web/test-files/ts-path-import-validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-path-import-validate.d.ts","sourceRoot":"","sources":["../../../../../../src/bin/utils/platform/web/test-files/ts-path-import-validate.ts"],"names":[],"mappings":""}

package/bundled/test-gen/bin/utils/platform/web/test-files/ts-path-import-validate.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+console.log(path_1.default);

package/bundled/test-gen/bin/utils/scenarios/index.d.ts

@@ -0,0 +1,6 @@
+import type { TestGenConfig } from "@empiricalrun/shared-types";
+import { CliOptions } from "../index";
+export declare function buildTokenFromOptions(options: Omit<CliOptions, "token">): string;
+export declare function buildTestConfigFromOptions(options: Omit<CliOptions, "token">): TestGenConfig;
+export declare function loadTestConfigs(testGenToken: string): TestGenConfig;
+//# sourceMappingURL=index.d.ts.map

package/bundled/test-gen/bin/utils/scenarios/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/bin/utils/scenarios/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,aAAa,EAEd,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAetC,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,GACjC,MAAM,CAgBR;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,GACjC,aAAa,CAaf;AAED,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,aAAa,CAmBnE"}

package/bundled/test-gen/bin/utils/scenarios/index.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTestConfigs = exports.buildTestConfigFromOptions = exports.buildTokenFromOptions = void 0;
+function buildTokenFromOptions(options) {
+    const genConfig = buildTestConfigFromOptions(options);
+    const requestConfig = {
+        specPath: genConfig.specPath,
+        id: genConfig.testCase.id,
+        name: genConfig.testCase.name,
+        steps: genConfig.testCase.steps,
+        filePath: genConfig.testCase.filePath,
+        suites: genConfig.testCase.suites,
+        ai_gist: genConfig.testCase.ai_gist,
+        build: genConfig.build,
+        options: genConfig.options,
+        environment: genConfig.environment,
+        testErrorDiagnosis: genConfig.testErrorDiagnosis,
+    };
+    return btoa(encodeURIComponent(JSON.stringify(requestConfig)));
+}
+exports.buildTokenFromOptions = buildTokenFromOptions;
+function buildTestConfigFromOptions(options) {
+    return {
+        specPath: `./tests/${options.file}`,
+        testCase: {
+            id: 0,
+            name: options.name,
+            steps: [options.prompt],
+            filePath: options.file,
+            suites: options.suites
+                ? options.suites.split(",").map((s) => s.trim())
+                : [],
+        },
+    };
+}
+exports.buildTestConfigFromOptions = buildTestConfigFromOptions;
+function loadTestConfigs(testGenToken) {
+    const str = decodeURIComponent(atob(testGenToken));
+    const config = JSON.parse(str);
+    const specPath = `./tests/${config.filePath || "index.spec.ts"}`;
+    return {
+        specPath,
+        testCase: {
+            id: config.id,
+            name: config.name,
+            steps: config.steps.filter((s) => !!s),
+            filePath: config.filePath,
+            suites: config.suites,
+            ai_gist: config.ai_gist,
+        },
+        testErrorDiagnosis: config.testErrorDiagnosis,
+        build: config.build,
+        options: config.options,
+        environment: config.environment,
+    };
+}
+exports.loadTestConfigs = loadTestConfigs;