@uuv/playwright 1.3.0

package/dist/reporter/uuv-playwright-reporter-helper.js

@@ -0,0 +1,400 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedReportType = void 0;
+const gherkin_1 = require("@cucumber/gherkin");
+const gherkin_utils_1 = require("@cucumber/gherkin-utils");
+const messages_1 = require("@cucumber/messages");
+const fs_1 = __importDefault(require("fs"));
+const runner_playwright_1 = require("../lib/runner-playwright");
+const multiple_cucumber_html_reporter_1 = __importDefault(require("multiple-cucumber-html-reporter"));
+const cucumber_json_report_formatter_1 = require("cucumber-json-report-formatter");
+const uuid_1 = require("uuid");
+const chalk_1 = __importDefault(require("chalk"));
+const chalk_table_1 = __importDefault(require("chalk-table"));
+const NANOS_IN_SECOND = 1000000000;
+const NANOS_IN_MILLISSECOND = 1000000;
+var GeneratedReportType;
+(function (GeneratedReportType) {
+    GeneratedReportType["CONSOLE"] = "console";
+    GeneratedReportType["HTML"] = "html";
+})(GeneratedReportType = exports.GeneratedReportType || (exports.GeneratedReportType = {}));
+class ReportOfFeature {
+    passed = 0;
+    skipped = 0;
+    failed = 0;
+    increment(status) {
+        if (status === "passed") {
+            this.passed++;
+        }
+        else if (status === "skipped") {
+            this.skipped++;
+        }
+        else if (status === "failed") {
+            this.failed++;
+        }
+    }
+}
+class UuvPlaywrightReporterHelper {
+    UUVPlaywrightCucumberMap = [];
+    testDir;
+    queries = new Map();
+    envelopes = [];
+    testCasesAndTestCasesStartedIdMap = new Map();
+    testCasesAndPickleIdMap = new Map();
+    testCasesTestStepStartedIdMap = new Map();
+    testStepLocationAndTestStepIdMap = new Map();
+    consoleReportMap = new Map();
+    errors = [];
+    createTestRunStartedEnvelope(config, suite, startTimestamp) {
+        this.testDir = config.projects[0].testDir;
+        this.loadUUVPlaywrightCucumberMap();
+        const featureFiles = this.getFeatureFiles(suite);
+        this.initializeCucumberReportNdJson(suite, featureFiles);
+        this.envelopes.push(this.createEnvelope({
+            testRunStarted: {
+                timestamp: startTimestamp
+            }
+        }));
+    }
+    createTestCaseStartedEnvelope(test, result, featureFile, startTimestamp) {
+        const currentQuery = this.queries.get(featureFile);
+        if (currentQuery) {
+            const newTestCaseEnvelope = this.createEnvelope({
+                testCase: {
+                    id: test.id,
+                    pickleId: this.testCasesAndPickleIdMap.get(test.id),
+                    testSteps: this.generateTestStep(currentQuery, test)
+                }
+            });
+            let newCurrentQuery = currentQuery.update(newTestCaseEnvelope);
+            this.envelopes.push(newTestCaseEnvelope);
+            const testCaseStartedId = (0, uuid_1.v4)();
+            const newTestCaseStartedEnvelope = this.createEnvelope({
+                testCaseStarted: {
+                    id: testCaseStartedId,
+                    testCaseId: test.id,
+                    attempt: result.retry,
+                    timestamp: startTimestamp
+                }
+            });
+            newCurrentQuery = newCurrentQuery.update(newTestCaseStartedEnvelope);
+            this.envelopes.push(newTestCaseStartedEnvelope);
+            this.queries.set(featureFile, newCurrentQuery);
+            this.testCasesAndTestCasesStartedIdMap.set(test.id, testCaseStartedId);
+            this.initConsoleReportIfNotExists(featureFile);
+        }
+    }
+    createTestStepStartedEnvelope(test, step, featureFile, startTimestamp) {
+        const currentQuery = this.queries.get(featureFile);
+        if (currentQuery && step.location) {
+            let newIndexStep = this.testCasesTestStepStartedIdMap.get(test.id);
+            newIndexStep = newIndexStep ? newIndexStep + 1 : 1;
+            const pickleId = this.testCasesAndPickleIdMap.get(test.id);
+            const pickle = currentQuery.getPickles()
+                .find(pickle => pickle.id === pickleId);
+            const testStep = pickle?.steps[newIndexStep - 1];
+            if (testStep?.id && step.title.endsWith(testStep.text)) {
+                this.testCasesTestStepStartedIdMap.set(test.id, newIndexStep);
+                this.testStepLocationAndTestStepIdMap.set(this.getTestStepKey(step.location), testStep.id);
+                const newTestStepEnvelope = this.createEnvelope({
+                    testStepStarted: {
+                        testStepId: testStep.id,
+                        testCaseStartedId: this.testCasesAndTestCasesStartedIdMap.get(test.id),
+                        timestamp: startTimestamp
+                    }
+                });
+                this.envelopes.push(newTestStepEnvelope);
+            }
+        }
+    }
+    createTestStepSkippedEnvelope(test, featureFile, timestamp) {
+        const currentQuery = this.queries.get(featureFile);
+        if (currentQuery) {
+            const newIndexStepTemp = this.testCasesTestStepStartedIdMap.get(test.id);
+            const newIndexStep = newIndexStepTemp !== undefined ? newIndexStepTemp + 1 : 1;
+            if (newIndexStep !== undefined) {
+                const pickleId = this.testCasesAndPickleIdMap.get(test.id);
+                currentQuery.getPickles()
+                    .find(pickle => pickle.id === pickleId)
+                    ?.steps
+                    .filter((value, index) => index >= (newIndexStep - 1))
+                    .forEach((pickleStep, index) => {
+                    const newTestStepStartedEnvelope = this.createEnvelope({
+                        testStepStarted: {
+                            testStepId: pickleStep.id,
+                            testCaseStartedId: this.testCasesAndTestCasesStartedIdMap.get(test.id),
+                            timestamp: timestamp
+                        }
+                    });
+                    this.envelopes.push(newTestStepStartedEnvelope);
+                    const newTestStepSkippedEnvelope = this.createEnvelope({
+                        testStepFinished: {
+                            testStepId: this.testCasesAndTestCasesStartedIdMap.get(test.id),
+                            testCaseStartedId: pickleStep.id,
+                            testStepResult: {
+                                status: "SKIPPED",
+                                duration: {
+                                    seconds: 0,
+                                    nanos: 0
+                                }
+                            },
+                            timestamp: timestamp
+                        }
+                    });
+                    this.envelopes.push(newTestStepSkippedEnvelope);
+                    this.consoleReportMap.get(featureFile)?.increment("skipped");
+                });
+            }
+        }
+    }
+    createTestStepFinishedEnvelope(test, step, result, featureFile, startTimestamp) {
+        const currentQuery = this.queries.get(featureFile);
+        if (currentQuery && step.location) {
+            const testStepId = this.testStepLocationAndTestStepIdMap.get(this.getTestStepKey(step.location));
+            if (testStepId) {
+                const newTestStepEnvelope = this.createEnvelope({
+                    testStepFinished: {
+                        testStepId: testStepId,
+                        testCaseStartedId: this.testCasesAndTestCasesStartedIdMap.get(test.id),
+                        testStepResult: {
+                            status: this.getStatus(step),
+                            duration: {
+                                seconds: result.duration / 1000,
+                                nanos: result.duration * NANOS_IN_MILLISSECOND
+                            }
+                        },
+                        timestamp: startTimestamp
+                    }
+                });
+                this.envelopes.push(newTestStepEnvelope);
+            }
+        }
+    }
+    getTestStepKey(location) {
+        return `${location.file.replaceAll("\\", "_")}-${location.line}-${location.column}`;
+    }
+    createTestCaseFinishedEnvelope(test, result, featureFile, endTimestamp) {
+        const currentQuery = this.queries.get(featureFile);
+        if (currentQuery) {
+            if (result.status === "skipped" || result.status === "failed") {
+                this.createTestStepSkippedEnvelope(test, featureFile, endTimestamp);
+            }
+            const newTestCaseFinishedEnvelope = this.createEnvelope({
+                testCaseFinished: {
+                    testCaseStartedId: this.testCasesAndTestCasesStartedIdMap.get(test.id),
+                    attempt: result.retry,
+                    timestamp: endTimestamp
+                }
+            });
+            currentQuery.update(newTestCaseFinishedEnvelope);
+            this.envelopes.push(newTestCaseFinishedEnvelope);
+            this.updateConsoleReport(featureFile, result);
+        }
+    }
+    initConsoleReportIfNotExists(featureFile) {
+        if (!this.consoleReportMap.get(featureFile)) {
+            this.consoleReportMap.set(featureFile, new ReportOfFeature());
+        }
+    }
+    updateConsoleReport(featureFile, result) {
+        this.consoleReportMap.get(featureFile)?.increment(result.status);
+    }
+    createTestRunFinishedEnvelope(result) {
+        const endDate = new Date();
+        const durationInSecond = endDate.getTime() / 1000;
+        this.envelopes.push((0, messages_1.parseEnvelope)(JSON.stringify({
+            testRunFinished: {
+                success: result.status === "passed",
+                timestamp: {
+                    seconds: durationInSecond,
+                    nanos: Math.floor(durationInSecond * NANOS_IN_SECOND + durationInSecond)
+                }
+            }
+        })));
+    }
+    async generateReport(reportType) {
+        this.displayConsoleReport();
+        if (reportType === GeneratedReportType.HTML) {
+            await this.generateHtmlReport();
+        }
+    }
+    getTimestamp(inpuDate) {
+        const date = inpuDate ? inpuDate : new Date();
+        const durationInSecond = date.getTime() / 1000;
+        const NANOS_IN_SECOND = 1000000000;
+        return {
+            seconds: durationInSecond,
+            nanos: Math.floor(durationInSecond * NANOS_IN_SECOND + durationInSecond)
+        };
+    }
+    getOriginalFeatureFile(generateFile) {
+        return this.UUVPlaywrightCucumberMap.find(item => item.generatedFile === generateFile)?.originalFile;
+    }
+    getCurrentRunningScenario(test, featureFile) {
+        const counter = `[${test.parent.allTests().filter(test => test.results.length > 0).length}/${test.parent.allTests().length}]`;
+        return `File ${featureFile} > Scenario ${counter} - ${test.title}`;
+    }
+    addError(newError) {
+        this.errors.push(newError);
+    }
+    getStatus(step) {
+        if (step.error === undefined) {
+            return "PASSED";
+        }
+        else {
+            return "FAILED";
+        }
+    }
+    createEnvelope(content) {
+        return (0, messages_1.parseEnvelope)(JSON.stringify(content));
+    }
+    createCucumberNdJsonFile(outputFileName) {
+        try {
+            console.log(`writting file ${outputFileName}`);
+            this.envelopes.forEach((envelope, index) => {
+                fs_1.default.writeFileSync(outputFileName, `${JSON.stringify(envelope)}\r\n`, {
+                    flag: index === 0 ? "w+" : "a"
+                });
+            });
+        }
+        catch (err) {
+            console.log(err);
+        }
+    }
+    loadUUVPlaywrightCucumberMap() {
+        this.UUVPlaywrightCucumberMap = JSON.parse(fs_1.default.readFileSync(`${this.testDir}/${runner_playwright_1.UUVPlaywrightCucumberMapFile}`, { encoding: "utf8" }));
+    }
+    initializeCucumberReportNdJson(suite, featureFiles) {
+        featureFiles.forEach(featureFile => {
+            const originalFile = this.getOriginalFeatureFile(featureFile);
+            if (originalFile) {
+                const currentEnvelopes = (0, gherkin_1.generateMessages)(fs_1.default.readFileSync(originalFile).toString(), originalFile, messages_1.SourceMediaType.TEXT_X_CUCUMBER_GHERKIN_PLAIN, {
+                    includeSource: true,
+                    includeGherkinDocument: true,
+                    newId: messages_1.IdGenerator.uuid(),
+                    includePickles: true
+                });
+                const currentQuery = new gherkin_utils_1.Query();
+                currentEnvelopes.forEach(envelope => currentQuery.update(envelope));
+                this.queries.set(originalFile, currentQuery);
+                this.envelopes = this.envelopes.concat(currentEnvelopes);
+                this.populateTestCasesAndPickleIdMap(currentQuery, suite, featureFile);
+            }
+        });
+    }
+    populateTestCasesAndPickleIdMap(currentQuery, suite, featureFile) {
+        const pickles = currentQuery.getPickles();
+        const featureFileTestSuite = suite.allTests()
+            .filter(testCase => testCase.location.file === featureFile);
+        featureFileTestSuite.forEach((testCase, index) => {
+            this.testCasesAndPickleIdMap.set(testCase.id, pickles[index].id);
+        });
+    }
+    generateTestStep(currentQuery, test) {
+        const pickleId = this.testCasesAndPickleIdMap.get(test.id);
+        return currentQuery.getPickles()
+            .find(pickle => pickle.id === pickleId)
+            ?.steps
+            .map((step) => {
+            return {
+                id: step.id,
+                pickleStepId: step.id,
+                stepDefinitionIds: [this.createStepDefinitionEnvelope()]
+            };
+        });
+    }
+    createStepDefinitionEnvelope() {
+        const stepDefinitionId = (0, uuid_1.v4)();
+        this.envelopes.push(this.createEnvelope({
+            stepDefinition: {
+                id: stepDefinitionId,
+                pattern: {
+                    source: "a step",
+                    type: "CUCUMBER_EXPRESSION"
+                },
+                sourceReference: {
+                    uri: "not available",
+                    location: {
+                        line: 0
+                    }
+                }
+            }
+        }));
+        return stepDefinitionId;
+    }
+    getFeatureFiles(suite) {
+        return [...new Set(suite.allTests().map(testCase => testCase.location?.file))];
+    }
+    async formatCucumberMessageFile(inputMessageFile, outputFormattedFileJson) {
+        const formatter = new cucumber_json_report_formatter_1.Formatter();
+        await formatter.parseCucumberJson(inputMessageFile, outputFormattedFileJson);
+    }
+    generateHtmlReportFromJson(reportDirHtml, reportDirJson) {
+        multiple_cucumber_html_reporter_1.default.generate({
+            jsonDir: reportDirJson,
+            reportPath: reportDirHtml
+        });
+    }
+    async generateHtmlReport() {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const reportDir = `${process.env.CONFIG_DIR}/reports`;
+        const outputMessageFile = `${reportDir}/cucumber-messages.ndjson`;
+        const reportDirHtml = `${reportDir}/html`;
+        const reportDirJson = `${reportDir}/json`;
+        const outputFormattedFileJson = `${reportDirJson}/cucumber-report.json`;
+        this.createdDirIfNeeded(reportDir);
+        this.createdDirIfNeeded(reportDirHtml);
+        this.createdDirIfNeeded(reportDirJson);
+        this.createCucumberNdJsonFile(outputMessageFile);
+        await this.formatCucumberMessageFile(outputMessageFile, outputFormattedFileJson);
+        this.generateHtmlReportFromJson(reportDirHtml, reportDirJson);
+    }
+    createdDirIfNeeded(reportDir) {
+        // Creating needed dirs
+        if (!fs_1.default.existsSync(reportDir)) {
+            fs_1.default.mkdirSync(reportDir, { recursive: true });
+        }
+    }
+    displayConsoleReport() {
+        const consoleReport = [];
+        const chalkTableOptions = {
+            leftPad: 2,
+            columns: [
+                { field: "id", name: "Id" },
+                { field: "file", name: "File" },
+                { field: "passed", name: chalk_1.default.green("Passed") },
+                { field: "skipped", name: chalk_1.default.yellow("Skipped") },
+                { field: "failed", name: chalk_1.default.red("Failed") }
+            ]
+        };
+        let index = 1;
+        this.consoleReportMap.forEach((value, key) => {
+            consoleReport.push({
+                id: index,
+                file: key,
+                passed: chalk_1.default.green(value.passed),
+                skipped: chalk_1.default.yellow(value.skipped),
+                failed: chalk_1.default.red(value.failed)
+            });
+            index++;
+        });
+        if (this.errors.length > 0) {
+            console.log("\n\n");
+            console.log(chalk_1.default.underline(chalk_1.default.bgRed(`${this.errors.length} Error(s) :`)));
+            this.errors.forEach(error => {
+                console.log(error.scenario);
+                console.log(chalk_1.default.red(error.error.toString()));
+                console.log("");
+            });
+            console.log("");
+        }
+        console.log(chalk_1.default.underline(chalk_1.default.bgBlue("Test Execution Report :")));
+        console.log((0, chalk_table_1.default)(chalkTableOptions, consoleReport));
+        console.log("\n\n");
+    }
+}
+exports.default = UuvPlaywrightReporterHelper;

package/dist/reporter/uuv-playwright-reporter.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { FullConfig, FullResult, Reporter, Suite, TestCase, TestResult } from "@playwright/test/reporter";
+import { TestError, TestStep } from "@playwright/test/types/testReporter";
+declare class UuvPlawrightReporter implements Reporter {
+    private helper;
+    private reporterStaticConsoleLogger;
+    onBegin(config: FullConfig, suite: Suite): void;
+    onError?(error: TestError): void;
+    onStdErr?(chunk: string | Buffer, test: void | TestCase, result: void | TestResult): void;
+    onTestBegin(test: TestCase, result: TestResult): void;
+    onStepBegin(test: TestCase, result: TestResult, step: TestStep): void;
+    onStepEnd(test: TestCase, result: TestResult, step: TestStep): void;
+    onTestEnd(test: TestCase, result: TestResult): void;
+    onEnd(result: FullResult): Promise<void>;
+}
+export default UuvPlawrightReporter;

package/dist/reporter/uuv-playwright-reporter.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const uuv_playwright_reporter_helper_1 = __importDefault(require("./uuv-playwright-reporter-helper"));
+const chalk_1 = __importDefault(require("chalk"));
+const draftlog_1 = __importDefault(require("draftlog"));
+class UuvPlawrightReporter {
+    helper = new uuv_playwright_reporter_helper_1.default();
+    reporterStaticConsoleLogger;
+    onBegin(config, suite) {
+        const startTimestamp = this.helper.getTimestamp();
+        // console.log(`Starting the run with ${suite.allTests().length} tests`);
+        this.helper.createTestRunStartedEnvelope(config, suite, startTimestamp);
+        (0, draftlog_1.default)(console).addLineListener(process.stdin);
+        console.log(chalk_1.default.yellow(`Starting the run with ${suite.allTests().length} tests`));
+        this.reporterStaticConsoleLogger = console.draft(chalk_1.default.yellow("!!! Fasten seat belt !!!"));
+    }
+    onError(error) {
+        console.dir(chalk_1.default.red(error));
+    }
+    onStdErr(chunk, test, result) {
+        let scenario = "unknown";
+        if (test?.id !== undefined) {
+            const featureFile = this.helper.getOriginalFeatureFile(test.location.file);
+            if (featureFile) {
+                scenario = this.helper.getCurrentRunningScenario(test, featureFile);
+            }
+        }
+        this.helper.addError({
+            scenario: scenario,
+            error: chunk
+        });
+    }
+    onTestBegin(test, result) {
+        const startTimestamp = this.helper.getTimestamp(result.startTime);
+        // console.log(`Starting test ${test.title} - ${test.parent.location?.file}`);
+        const featureFile = this.helper.getOriginalFeatureFile(test.location.file);
+        if (featureFile) {
+            this.reporterStaticConsoleLogger(chalk_1.default.blueBright(`Running > ${this.helper.getCurrentRunningScenario(test, featureFile)}`));
+            this.helper.createTestCaseStartedEnvelope(test, result, featureFile, startTimestamp);
+        }
+    }
+    onStepBegin(test, result, step) {
+        const startTimestamp = this.helper.getTimestamp(result.startTime);
+        // console.log(`Starting step ${test.title} - ${step.title} - ${step.location?.file} - ${step.location?.line} - ${step.location?.column}`);
+        const featureFile = this.helper.getOriginalFeatureFile(test.location.file);
+        if (featureFile) {
+            this.helper.createTestStepStartedEnvelope(test, step, featureFile, startTimestamp);
+        }
+    }
+    onStepEnd(test, result, step) {
+        const endTimestamp = this.helper.getTimestamp(result.startTime);
+        // console.log(`End step ${test.title} - ${step.title} - ${result.status} - ${step.error}`);
+        const featureFile = this.helper.getOriginalFeatureFile(test.location.file);
+        if (featureFile) {
+            this.helper.createTestStepFinishedEnvelope(test, step, result, featureFile, endTimestamp);
+        }
+    }
+    onTestEnd(test, result) {
+        const endTimestamp = this.helper.getTimestamp();
+        // console.log(`Finished test ${test.title}: ${result.status}`);
+        const featureFile = this.helper.getOriginalFeatureFile(test.location.file);
+        if (featureFile) {
+            this.helper.createTestCaseFinishedEnvelope(test, result, featureFile, endTimestamp);
+        }
+    }
+    async onEnd(result) {
+        // console.debug(`Finished the run: ${result.status}`);
+        this.helper.createTestRunFinishedEnvelope(result);
+        console.log(chalk_1.default.yellow("End of the tests execution"));
+        await this.helper.generateReport(
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        process.env.REPORT_TYPE);
+        if (result.status === "passed") {
+            console.log(chalk_1.default.green("Tests executed successfully"));
+        }
+        else {
+            console.error(chalk_1.default.red(`Tests executed with status: ${result.status}`));
+        }
+    }
+}
+exports.default = UuvPlawrightReporter;

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@uuv/playwright",
+  "version": "1.3.0",
+  "type": "commonjs",
+  "author": "Louis Fredice NJAKO MOLOM (https://github.com/luifr10) & Stanley SERVICAL (https://github.com/stanlee974)",
+  "description": "A transpiler from cucumber step definitions to cypress.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/e2e-test-quest/uuv"
+  },
+  "homepage": "https://e2e-test-quest.github.io/uuv/",
+  "bin": {
+    "uuv": "bin/uuv"
+  },
+  "keywords": [
+    "uuv",
+    "UUV",
+    "E2E",
+    "test",
+    "testing",
+    "accessibility",
+    "accessibilité",
+    "a11y",
+    "playwright",
+    "testing-library",
+    "cucumber",
+    "gherkin"
+  ],
+  "scripts": {
+    "generate:step-definitions": "ts-node generate-step-definitions.ts",
+    "package": "npm pack --pack-destination=\"../../dist/packages\"",
+    "postinstall": "node postinstall.js",
+    "serverTest:run": "ts-node playwright/run-test-app.ts 9002",
+    "test:run": "ts-node test.ts run",
+    "test:open": "ts-node test.ts open",
+    "test:alone:run": "npx playwright test",
+    "test:format": "ts-node format-cucumber-report.ts",
+    "test": "npm run test:run"
+  },
+  "dependencies": {
+    "@cucumber/cucumber": "9.1.0",
+    "@playwright/test": "1.33.0",
+    "@uuv/runner-commons": "1.3.0",
+    "axe-core": "4.7.0",
+    "axe-playwright": "1.2.3",
+    "chalk": "4.1.2",
+    "chalk-table": "^1.0.2",
+    "cucumber-json-report-formatter": "0.1.4",
+    "draftlog": "1.0.13",
+    "figlet": "1.6.0",
+    "minimist": "1.2.8",
+    "multiple-cucumber-html-reporter": "3.3.0",
+    "ts-node": "10.9.1",
+    "typescript": "4.9.5"
+  },
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "files": [
+    "dist/cucumber/**/*",
+    "dist/reporter/**/*",
+    "dist/lib/**/*",
+    "dist/index.d.ts",
+    "dist/index.js",
+    "bin/**/*",
+    "postinstall.js",
+    "target-config/**/*",
+    "src/cucumber/step_definitions/playwright/generated/**/*",
+    "*.md"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./uuv-playwright-reporter": {
+      "import": "./dist/reporter/uuv-playwright-reporter.js",
+      "require": "./dist/reporter/uuv-playwright-reporter.js",
+      "types": "./dist/reporter/uuv-playwright-reporter.d.ts"
+    }
+  },
+  "devDependencies": {
+    "@types/minimist": "1.2.2",
+    "@types/node": "18.15.11",
+    "cross-env": "7.0.3",
+    "eslint-plugin-cucumber": "2.0.0",
+    "eslint-plugin-jest": "27.2.1",
+    "eslint-plugin-playwright": "0.12.0",
+    "ts-loader": "9.4.2",
+    "tsconfig-paths": "4.2.0",
+    "webpack": "5.81.0"
+  }
+}

package/postinstall.js

@@ -0,0 +1,51 @@
+/**
+ * Copyright UUV.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const fs = require("fs");
+const PROJECT_DIR = `${__dirname}/../../../`;
+const CLI_DIR = `${__dirname}/dist/lib`;
+const TARGET_CONFIG_DIR = `${__dirname}/target-config`;
+
+function copyFile(fileToCopy, originFolder, destFolder) {
+    if (fs.existsSync(`${originFolder}/${fileToCopy}`)) {
+        if (!fs.existsSync(destFolder)) {
+            fs.mkdirSync(destFolder, { recursive: true });
+        }
+        fs.copyFile(`${originFolder}/${fileToCopy}`, `${destFolder}/${fileToCopy}`, (err) => {
+            if (err) {
+throw err;
+}
+            console.log(`File ${destFolder}/${fileToCopy} created`);
+        });
+    }
+}
+
+function copyFileIfMissing(fileToCopy, originFolder, destFolder) {
+    if (!fs.existsSync(`${destFolder}/${fileToCopy}`)) {
+        copyFile(fileToCopy, originFolder, destFolder);
+    }
+}
+
+function main () {
+    if (fs.existsSync(`${PROJECT_DIR}/package.json`) && !fs.existsSync(`${PROJECT_DIR}/.no-postinstall`)) {
+        copyFileIfMissing("playwright.config.ts", `${TARGET_CONFIG_DIR}`, `${PROJECT_DIR}/uuv`);
+        copyFileIfMissing("cucumber.cjs", `${TARGET_CONFIG_DIR}`, `${PROJECT_DIR}`);
+    } else {
+        console.log("postinstall - Nothing to copy");
+    }
+}
+
+main();