@empiricalrun/playwright-utils 0.23.0 → 0.23.1

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

@@ -1,544 +0,0 @@
-"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

@@ -1,2 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,7 +0,0 @@
-"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

@@ -1,6 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,57 +0,0 @@
-"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;