@nx/playwright 0.0.0-pr-22179-271588f

package/src/generators/configuration/configuration.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configurationGeneratorInternal = exports.configurationGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const versions_1 = require("@nx/js/src/utils/versions");
+const child_process_1 = require("child_process");
+const path = require("path");
+const add_linter_1 = require("../../utils/add-linter");
+const versions_2 = require("../../utils/versions");
+const init_1 = require("../init/init");
+function configurationGenerator(tree, options) {
+    return configurationGeneratorInternal(tree, { addPlugin: false, ...options });
+}
+exports.configurationGenerator = configurationGenerator;
+async function configurationGeneratorInternal(tree, options) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    options.addPlugin ??=
+        process.env.NX_ADD_PLUGINS !== 'false' &&
+            nxJson.useInferencePlugins !== false;
+    const tasks = [];
+    tasks.push(await (0, init_1.initGenerator)(tree, {
+        skipFormat: true,
+        skipPackageJson: options.skipPackageJson,
+        addPlugin: options.addPlugin,
+    }));
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const hasTsConfig = tree.exists((0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.json'));
+    const offsetFromProjectRoot = (0, devkit_1.offsetFromRoot)(projectConfig.root);
+    (0, devkit_1.generateFiles)(tree, path.join(__dirname, 'files'), projectConfig.root, {
+        offsetFromRoot: offsetFromProjectRoot,
+        projectRoot: projectConfig.root,
+        webServerCommand: options.webServerCommand ?? null,
+        webServerAddress: options.webServerAddress ?? null,
+        ...options,
+    });
+    if (!hasTsConfig) {
+        tree.write(`${projectConfig.root}/tsconfig.json`, JSON.stringify({
+            extends: (0, js_1.getRelativePathToRootTsConfig)(tree, projectConfig.root),
+            compilerOptions: {
+                allowJs: true,
+                outDir: `${offsetFromProjectRoot}dist/out-tsc`,
+                module: 'commonjs',
+                sourceMap: false,
+            },
+            include: [
+                '**/*.ts',
+                '**/*.js',
+                'playwright.config.ts',
+                'src/**/*.spec.ts',
+                'src/**/*.spec.js',
+                'src/**/*.test.ts',
+                'src/**/*.test.js',
+                'src/**/*.d.ts',
+            ],
+        }, null, 2));
+    }
+    const hasPlugin = (0, devkit_1.readNxJson)(tree).plugins?.some((p) => typeof p === 'string'
+        ? p === '@nx/playwright/plugin'
+        : p.plugin === '@nx/playwright/plugin');
+    if (!hasPlugin) {
+        addE2eTarget(tree, options);
+        setupE2ETargetDefaults(tree);
+    }
+    tasks.push(await (0, add_linter_1.addLinterToPlaywrightProject)(tree, {
+        project: options.project,
+        linter: options.linter,
+        skipPackageJson: options.skipPackageJson,
+        js: options.js,
+        directory: options.directory,
+        setParserOptionsProject: options.setParserOptionsProject,
+        rootProject: options.rootProject ?? projectConfig.root === '.',
+        addPlugin: options.addPlugin,
+    }));
+    if (options.js) {
+        const { ModuleKind } = (0, devkit_1.ensurePackage)('typescript', versions_1.typescriptVersion);
+        (0, devkit_1.toJS)(tree, { extension: '.cjs', module: ModuleKind.CommonJS });
+    }
+    recommendVsCodeExtensions(tree);
+    if (!options.skipPackageJson) {
+        tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            // required since used in playwright config
+            '@nx/devkit': versions_2.nxVersion,
+        }));
+    }
+    if (!options.skipInstall) {
+        tasks.push(getBrowsersInstallTask());
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.configurationGeneratorInternal = configurationGeneratorInternal;
+function getBrowsersInstallTask() {
+    return () => {
+        devkit_1.output.log({
+            title: 'Ensuring Playwright is installed.',
+            bodyLines: ['use --skipInstall to skip installation.'],
+        });
+        const pmc = (0, devkit_1.getPackageManagerCommand)();
+        (0, child_process_1.execSync)(`${pmc.exec} playwright install`, { cwd: devkit_1.workspaceRoot });
+    };
+}
+function recommendVsCodeExtensions(tree) {
+    if (tree.exists('.vscode/extensions.json')) {
+        (0, devkit_1.updateJson)(tree, '.vscode/extensions.json', (json) => {
+            json.recommendations ??= [];
+            const recs = new Set(json.recommendations);
+            recs.add('ms-playwright.playwright');
+            json.recommendations = Array.from(recs);
+            return json;
+        });
+    }
+    else {
+        (0, devkit_1.writeJson)(tree, '.vscode/extensions.json', {
+            recommendations: ['ms-playwright.playwright'],
+        });
+    }
+}
+function setupE2ETargetDefaults(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (!nxJson.namedInputs) {
+        return;
+    }
+    // E2e targets depend on all their project's sources + production sources of dependencies
+    nxJson.targetDefaults ??= {};
+    const productionFileSet = !!nxJson.namedInputs?.production;
+    nxJson.targetDefaults.e2e ??= {};
+    nxJson.targetDefaults.e2e.cache ??= true;
+    nxJson.targetDefaults.e2e.inputs ??= [
+        'default',
+        productionFileSet ? '^production' : '^default',
+    ];
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+function addE2eTarget(tree, options) {
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    if (projectConfig?.targets?.e2e) {
+        throw new Error(`Project ${options.project} already has an e2e target.
+Rename or remove the existing e2e target.`);
+    }
+    projectConfig.targets ??= {};
+    projectConfig.targets.e2e = {
+        executor: '@nx/playwright:playwright',
+        outputs: [`{workspaceRoot}/dist/.playwright/${projectConfig.root}`],
+        options: {
+            config: `${projectConfig.root}/playwright.config.${options.js ? 'cjs' : 'ts'}`,
+        },
+    };
+    (0, devkit_1.updateProjectConfiguration)(tree, options.project, projectConfig);
+}
+exports.default = configurationGenerator;

package/src/generators/configuration/files/__directory__/example.spec.ts.template

@@ -0,0 +1,8 @@
+import { test, expect } from '@playwright/test';
+
+test('has title', async ({ page }) => {
+  await page.goto('/');
+
+  // Expect h1 to contain a substring.
+  expect(await page.locator('h1').innerText()).toContain('Welcome');
+});

package/src/generators/configuration/files/playwright.config.ts.template

@@ -0,0 +1,75 @@
+import { defineConfig, devices } from '@playwright/test';
+import { nxE2EPreset } from '@nx/playwright/preset';
+<% if(!webServerCommand || !webServerAddress) { %>// eslint-disable-next-line @typescript-eslint/no-unused-vars <% } %>
+import { workspaceRoot } from '@nx/devkit';
+
+// For CI, you may want to set BASE_URL to the deployed application.
+const baseURL = process.env['BASE_URL'] || '<% if(webServerAddress) {%><%= webServerAddress %><% } else {%>http://localhost:3000<% } %>';
+
+/**
+ * Read environment variables from file.
+ * https://github.com/motdotla/dotenv
+ */
+// require('dotenv').config();
+
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+export default defineConfig({
+  ...nxE2EPreset(__filename, { testDir: './<%= directory %>' }),
+  /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+  use: {
+    baseURL,
+    /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+    trace: 'on-first-retry',
+  },
+  /* Run your local dev server before starting the tests */<% if(webServerCommand && webServerAddress) {%>
+  webServer: {
+    command: '<%= webServerCommand %>',
+    url: '<%= webServerAddress %>',
+    reuseExistingServer: !process.env.CI,
+    cwd: workspaceRoot
+  },<% } else {%>
+  // webServer: {
+  //   command: 'npm run start',
+  //   url: 'http://127.0.0.1:3000',
+  //   reuseExistingServer: !process.env.CI,
+  //   cwd: workspaceRoot,
+  // },<% } %>
+  projects: [
+    {
+      name: "chromium",
+      use: { ...devices["Desktop Chrome"] },
+    },
+
+    {
+      name: "firefox",
+      use: { ...devices["Desktop Firefox"] },
+    },
+
+    {
+      name: "webkit",
+      use: { ...devices["Desktop Safari"] },
+    },
+    
+    // Uncomment for mobile browsers support
+    /* {
+      name: 'Mobile Chrome',
+      use: { ...devices['Pixel 5'] },
+    },
+    {
+      name: 'Mobile Safari',
+      use: { ...devices['iPhone 12'] },
+    }, */
+
+    // Uncomment for branded browsers
+    /* {
+      name: 'Microsoft Edge',
+      use: { ...devices['Desktop Edge'], channel: 'msedge' },
+    },
+    {
+      name: 'Google Chrome',
+      use: { ...devices['Desktop Chrome'], channel: 'chrome' },
+    } */
+  ],
+});

package/src/generators/configuration/schema.d.ts

@@ -0,0 +1,27 @@
+import type { Linter } from '@nx/eslint';
+
+export interface ConfigurationGeneratorSchema {
+  project: string;
+  /**
+   * this is relative to the projectRoot
+   **/
+  directory: string;
+  js: boolean; // default is false
+  skipFormat: boolean;
+  skipPackageJson: boolean;
+  skipInstall?: boolean;
+  linter: Linter;
+  setParserOptionsProject: boolean; // default is false
+  /**
+   * command to give playwright to run the web server
+   * @example: "npx nx serve my-fe-app"
+   **/
+  webServerCommand?: string;
+  /**
+   * address
+   * @example: "http://localhost:4200"
+   **/
+  webServerAddress?: string;
+  rootProject?: boolean;
+  addPlugin?: boolean;
+}

package/src/generators/configuration/schema.json

@@ -0,0 +1,73 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxPlaywrightConfiguration",
+  "description": "Add a Playwright configuration.",
+  "title": "Add a Playwright configuration",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The project to add a Playwright configuration to.",
+      "$default": {
+        "$source": "projectName"
+      },
+      "x-priority": "important",
+      "x-prompt": "What is the name of the project to set up Playwright for?"
+    },
+    "directory": {
+      "type": "string",
+      "description": "A directory where the project is placed relative from the project root.",
+      "x-priority": "important",
+      "default": "e2e"
+    },
+    "js": {
+      "type": "boolean",
+      "description": "Generate JavaScript files rather than TypeScript files.",
+      "default": false
+    },
+    "webServerCommand": {
+      "type": "string",
+      "description": "The command to start the web server."
+    },
+    "webServerAddress": {
+      "type": "string",
+      "description": "The address of the web server."
+    },
+    "linter": {
+      "description": "The tool to use for running lint checks.",
+      "type": "string",
+      "enum": ["eslint", "none"],
+      "default": "eslint"
+    },
+    "setParserOptionsProject": {
+      "type": "boolean",
+      "description": "Whether or not to configure the ESLint `parserOptions.project` option. We do not do this by default for lint performance reasons.",
+      "default": false
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add dependencies to `package.json`.",
+      "x-priority": "internal"
+    },
+    "rootProject": {
+      "description": "Create a application at the root of the workspace",
+      "type": "boolean",
+      "default": false,
+      "hidden": true,
+      "x-priority": "internal"
+    },
+    "skipInstall": {
+      "type": "boolean",
+      "description": "Skip running `playwright install`. This is to ensure that playwright browsers are installed.",
+      "default": false
+    }
+  },
+  "required": ["project"]
+}

package/src/generators/init/init.d.ts

@@ -0,0 +1,5 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { InitGeneratorSchema } from './schema';
+export declare function initGenerator(tree: Tree, options: InitGeneratorSchema): Promise<GeneratorCallback>;
+export declare function initGeneratorInternal(tree: Tree, options: InitGeneratorSchema): Promise<GeneratorCallback>;
+export default initGenerator;

package/src/generators/init/init.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initGeneratorInternal = exports.initGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const update_package_scripts_1 = require("@nx/devkit/src/utils/update-package-scripts");
+const plugin_1 = require("../../plugins/plugin");
+const versions_1 = require("../../utils/versions");
+function initGenerator(tree, options) {
+    return initGeneratorInternal(tree, { addPlugin: false, ...options });
+}
+exports.initGenerator = initGenerator;
+async function initGeneratorInternal(tree, options) {
+    const tasks = [];
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    options.addPlugin ??= addPluginDefault;
+    if (!options.skipPackageJson) {
+        tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@nx/playwright': versions_1.nxVersion,
+            '@playwright/test': versions_1.playwrightVersion,
+        }, undefined, options.keepExistingVersions));
+    }
+    if (options.addPlugin) {
+        addPlugin(tree);
+    }
+    if (options.updatePackageScripts) {
+        await (0, update_package_scripts_1.updatePackageScripts)(tree, plugin_1.createNodes);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.initGeneratorInternal = initGeneratorInternal;
+function addPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    nxJson.plugins ??= [];
+    if (!nxJson.plugins.some((p) => typeof p === 'string'
+        ? p === '@nx/playwright/plugin'
+        : p.plugin === '@nx/playwright/plugin')) {
+        nxJson.plugins.push({
+            plugin: '@nx/playwright/plugin',
+            options: {
+                targetName: 'e2e',
+            },
+        });
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+}
+exports.default = initGenerator;

package/src/generators/init/schema.d.ts

@@ -0,0 +1,7 @@
+export interface InitGeneratorSchema {
+  skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  keepExistingVersions?: boolean;
+  updatePackageScripts?: boolean;
+  addPlugin?: boolean;
+}

package/src/generators/init/schema.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxPlaywrightInit",
+  "title": "Playwright Init Generator",
+  "description": "Initializes a Playwright project in the current workspace.",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add dependencies to `package.json`.",
+      "x-priority": "internal"
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Keep existing dependencies versions",
+      "default": false
+    },
+    "updatePackageScripts": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Update `package.json` scripts with inferred targets",
+      "default": false
+    }
+  },
+  "required": []
+}

package/src/migrations/update-17-3-1/add-project-to-config.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;

package/src/migrations/update-17-3-1/add-project-to-config.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const ts = require("typescript");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+async function update(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    projects.forEach((project) => {
+        // Check if the project contains playwright config
+        const configPath = (0, devkit_1.joinPathFragments)(project.root, 'playwright.config.ts');
+        if (tree.exists(configPath)) {
+            addProjectIfExists(tree, (0, devkit_1.joinPathFragments)(configPath));
+        }
+    });
+}
+exports.default = update;
+function addProjectIfExists(tree, configFilePath) {
+    const configFileContent = tree.read(configFilePath, 'utf-8');
+    const sourceFile = tsquery_1.tsquery.ast(configFileContent);
+    const printer = ts.createPrinter();
+    const updatedStatements = updateOrCreateImportStatement(sourceFile, '@playwright/test', ['devices']);
+    const exportAssignment = tsquery_1.tsquery.query(sourceFile, 'ExportAssignment')[0];
+    if (!exportAssignment) {
+        // No export found in the file
+        return;
+    }
+    const exportAssignemntObject = exportAssignment.expression;
+    if (!(ts.isCallExpression(exportAssignemntObject) &&
+        exportAssignemntObject.getText(sourceFile).startsWith('defineConfig') &&
+        exportAssignemntObject.arguments.length > 0)) {
+        // Export is not a call expression with defineConfig ex. export default defineConfig({ ... })
+        return;
+    }
+    let firstArgument = exportAssignemntObject.arguments[0];
+    if (!ts.isObjectLiteralExpression(firstArgument)) {
+        // First argument is not an object literal ex. defineConfig('foo')
+        return;
+    }
+    const projectProperty = tsquery_1.tsquery.query(exportAssignemntObject, 'PropertyAssignment > Identifier[name="projects"]')[0];
+    if (projectProperty) {
+        // Projects property already exists in the config
+        return;
+    }
+    // Add projects property to the config
+    const projectsArray = ts.factory.createArrayLiteralExpression([
+        createProperty('chromium', 'Desktop Chrome'),
+        createProperty('firefox', 'Desktop Firefox'),
+        createProperty('webkit', 'Desktop Safari'),
+    ], true);
+    const newProjectsProperty = ts.factory.createPropertyAssignment('projects', projectsArray);
+    const newObj = ts.factory.createObjectLiteralExpression([
+        ...firstArgument.properties,
+        newProjectsProperty,
+    ]);
+    const newCallExpression = ts.factory.updateCallExpression(exportAssignemntObject, exportAssignemntObject.expression, exportAssignemntObject.typeArguments, [newObj]);
+    const newExportAssignment = ts.factory.updateExportAssignment(exportAssignment, exportAssignment.modifiers, newCallExpression);
+    const transformedStatements = updatedStatements.map((statement) => {
+        return statement === exportAssignment ? newExportAssignment : statement;
+    });
+    const transformedSourceFile = ts.factory.updateSourceFile(sourceFile, transformedStatements);
+    const updatedConfigFileContent = printer.printFile(transformedSourceFile);
+    tree.write(configFilePath, updatedConfigFileContent);
+}
+function createProperty(name, device) {
+    return ts.factory.createObjectLiteralExpression([
+        ts.factory.createPropertyAssignment('name', ts.factory.createStringLiteral(name)),
+        ts.factory.createPropertyAssignment('use', ts.factory.createObjectLiteralExpression([
+            ts.factory.createSpreadAssignment(ts.factory.createElementAccessExpression(ts.factory.createIdentifier('devices'), ts.factory.createStringLiteral(device))),
+        ])),
+    ]);
+}
+function updateOrCreateImportStatement(sourceFile, moduleName, importNames) {
+    let importDeclarationFound = false;
+    const newStatements = sourceFile.statements.map((statement) => {
+        if (ts.isImportDeclaration(statement) &&
+            statement.moduleSpecifier.getText(sourceFile) === `'${moduleName}'`) {
+            importDeclarationFound = true;
+            const existingSpecifiers = statement.importClause?.namedBindings &&
+                ts.isNamedImports(statement.importClause.namedBindings)
+                ? statement.importClause.namedBindings.elements.map((e) => e.name.text)
+                : [];
+            // Merge with new import names, avoiding duplicates
+            const mergedImportNames = Array.from(new Set([...existingSpecifiers, ...importNames]));
+            // Create new import specifiers
+            const importSpecifiers = mergedImportNames.map((name) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(name)));
+            return ts.factory.updateImportDeclaration(statement, statement.modifiers, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(importSpecifiers)), statement.moduleSpecifier, undefined);
+        }
+        return statement;
+    });
+    if (!importDeclarationFound) {
+        const importDeclaration = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(importNames.map((name) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(name))))), ts.factory.createStringLiteral(moduleName));
+        newStatements.push(importDeclaration);
+    }
+    return newStatements;
+}

package/src/migrations/update-18-1-0/remove-baseUrl-from-project-json.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<void>;

package/src/migrations/update-18-1-0/remove-baseUrl-from-project-json.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+async function default_1(tree) {
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/playwright:playwright', (options, projectName, targetName, configurationName) => {
+        if (options?.['baseUrl']) {
+            const project = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+            if (configurationName) {
+                delete project.targets[targetName].configurations[configurationName]['baseUrl'];
+            }
+            else {
+                delete project.targets[targetName].options['baseUrl'];
+            }
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, project);
+        }
+    });
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    for (const [targetNameOrExecutor, target] of Object.entries(nxJson.targetDefaults)) {
+        if (targetNameOrExecutor === '@nx/playwright:playwright' ||
+            (target.executor && target.executor === '@nx/playwright:playwright')) {
+            let updated = false;
+            if (target.options?.['baseUrl']) {
+                delete nxJson.targetDefaults[targetNameOrExecutor].options['baseUrl'];
+                updated = true;
+            }
+            if (target.configurations) {
+                for (const [configurationName, configuration] of Object.entries(target.configurations)) {
+                    if (configuration['baseUrl']) {
+                        delete nxJson.targetDefaults[targetNameOrExecutor].configurations[configurationName]['baseUrl'];
+                        updated = true;
+                    }
+                }
+            }
+            if (updated) {
+                (0, devkit_1.updateNxJson)(tree, nxJson);
+            }
+        }
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;

package/src/plugins/plugin.d.ts

@@ -0,0 +1,7 @@
+import { CreateDependencies, CreateNodes } from '@nx/devkit';
+export interface PlaywrightPluginOptions {
+    targetName?: string;
+    ciTargetName?: string;
+}
+export declare const createDependencies: CreateDependencies;
+export declare const createNodes: CreateNodes<PlaywrightPluginOptions>;