playwright-ctrf-json-reporter 0.0.27 → 0.0.28-next-1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Matthew Thomas
+Copyright (c) 2024 Matthew Poulton-White
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -6,29 +6,20 @@ A Playwright JSON test reporter to create test reports that follow the CTRF stan
 
 [Common Test Report Format](https://ctrf.io) ensures the generation of uniform JSON test reports, independent of programming languages or test framework in use.
 
-<div align="center">
-<div style="padding: 1.5rem; border-radius: 8px; margin: 1rem 0; border: 1px solid #30363d;">
-<span style="font-size: 23px;">💚</span>
-<h3 style="margin: 1rem 0;">CTRF tooling is open source and free to use</h3>
-<p style="font-size: 16px;">You can support the project with a follow and a star</p>
-
-<div style="margin-top: 1.5rem;">
-<a href="https://github.com/ctrf-io/playwright-ctrf-json-reporter">
-<img src="https://img.shields.io/github/stars/ctrf-io/playwright-ctrf-json-reporter?style=for-the-badge&color=2ea043" alt="GitHub stars">
-</a>
-<a href="https://github.com/ctrf-io">
-<img src="https://img.shields.io/github/followers/ctrf-io?style=for-the-badge&color=2ea043" alt="GitHub followers">
-</a>
-</div>
-</div>
-<p style="font-size: 14px; margin: 1rem 0;">
-
-Contributions are very welcome! <br/>
-Explore more <a href="https://www.ctrf.io/integrations">integrations</a> <br/>
-<a href="https://app.formbricks.com/s/cmefs524mhlh1tl01gkpvefrb">Let us know your thoughts</a>.
-
-</p>
-</div>
+## CTRF Open Standard
+
+CTRF is a community-driven open standard for test reporting.
+
+By standardizing test results, reports can be validated, merged, compared, and analyzed consistently across languages and frameworks.
+
+- **CTRF Specification**: https://github.com/ctrf-io/ctrf  
+  The official specification defining the format and semantics
+- **Discussions**: https://github.com/orgs/ctrf-io/discussions  
+  Community forum for questions, ideas, and support
+
+> [!NOTE]  
+> ⭐ Starring the **CTRF specification repository** (https://github.com/ctrf-io/ctrf)
+> helps support the standard.
 
 ## Features
 
@@ -259,7 +250,3 @@ CTRF is a universal JSON test report schema that addresses the lack of a standar
 **Language and Framework Agnostic:** It provides a universal reporting schema that works seamlessly with any programming language and testing framework.
 
 **Facilitates Better Analysis:** With a standardized format, programatically analyzing test outcomes across multiple platforms becomes more straightforward.
-
-## Support Us
-
-If you find this project useful, consider giving it a GitHub star ⭐ It means a lot to us.

package/dist/adapter/index.d.ts

@@ -0,0 +1,2 @@
+export { ctrf, extra, CTRF_RUNTIME_MESSAGE_CONTENT_TYPE } from './runtime';
+export type { CtrfRuntimeMessage, CtrfRuntimeMessageType } from './runtime';

package/dist/adapter/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CTRF_RUNTIME_MESSAGE_CONTENT_TYPE = exports.extra = exports.ctrf = void 0;
+var runtime_1 = require("./runtime");
+Object.defineProperty(exports, "ctrf", { enumerable: true, get: function () { return runtime_1.ctrf; } });
+Object.defineProperty(exports, "extra", { enumerable: true, get: function () { return runtime_1.extra; } });
+Object.defineProperty(exports, "CTRF_RUNTIME_MESSAGE_CONTENT_TYPE", { enumerable: true, get: function () { return runtime_1.CTRF_RUNTIME_MESSAGE_CONTENT_TYPE; } });

package/dist/adapter/runtime.d.ts

@@ -0,0 +1,80 @@
+/**
+ * CTRF Runtime API for Playwright
+ *
+ * Enables enriching CTRF test reports with custom metadata at runtime.
+ * Metadata is collected via Playwright's native attachment mechanism and
+ * consolidated by the reporter into the test's `extra` field.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { ctrf } from 'playwright-ctrf-json-reporter'
+ *
+ * test('checkout flow', async ({ page }) => {
+ *   ctrf.extra({ owner: 'checkout-team', priority: 'P1' })
+ *   // ... test code
+ *   ctrf.extra({ customMetric: calculateValue() })
+ * })
+ * ```
+ *
+ * ## API
+ *
+ * - `ctrf.extra(data)` - Attach key-value metadata to the current test
+ *
+ * ## Behavior
+ *
+ * - Call multiple times; all data is collected and merged
+ * - Works from any function in the call stack during test execution
+ * - Silently ignored when called outside test context
+ * - Deep merge: arrays concatenate, objects merge recursively, primitives overwrite
+ */
+/**
+ * Content type used to identify CTRF runtime messages in attachments.
+ * The reporter will look for attachments with this content type.
+ */
+export declare const CTRF_RUNTIME_MESSAGE_CONTENT_TYPE = "application/vnd.ctrf.message+json";
+/**
+ * Runtime message types
+ */
+export type CtrfRuntimeMessageType = 'metadata';
+/**
+ * A runtime message sent from test code to the reporter
+ */
+export interface CtrfRuntimeMessage {
+    type: CtrfRuntimeMessageType;
+    data: Record<string, unknown>;
+}
+/**
+ * Attach custom metadata to the current test.
+ *
+ * @param data - Key-value pairs to include in the CTRF report's `extra` field
+ * @returns Promise (can be ignored; completes when attachment is written)
+ *
+ * @remarks
+ * - **Arrays**: Concatenated across calls (duplicates allowed)
+ * - **Objects**: Deep merged (nested keys preserved)
+ * - **Primitives**: Later calls overwrite earlier ones
+ * - Safe to call from helper functions - binds to the active test automatically
+ * - No-op outside test context (e.g., in global setup)
+ *
+ * @example
+ * // Arrays concatenate
+ * ctrf.extra({ tags: ['smoke'] })
+ * ctrf.extra({ tags: ['e2e'] })
+ * // → { tags: ['smoke', 'e2e'] }
+ *
+ * // Objects merge deeply
+ * ctrf.extra({ build: { id: 'abc' } })
+ * ctrf.extra({ build: { url: 'https://...' } })
+ * // → { build: { id: 'abc', url: 'https://...' } }
+ *
+ * // Primitives overwrite
+ * ctrf.extra({ owner: 'platform-team' })
+ * ctrf.extra({ owner: 'checkout-team' })
+ * // → { owner: 'checkout-team' }
+ */
+export declare function extra(data: Record<string, unknown>): Promise<void>;
+/** CTRF runtime API namespace */
+export declare const ctrf: {
+    readonly extra: typeof extra;
+};

package/dist/adapter/runtime.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * CTRF Runtime API for Playwright
+ *
+ * Enables enriching CTRF test reports with custom metadata at runtime.
+ * Metadata is collected via Playwright's native attachment mechanism and
+ * consolidated by the reporter into the test's `extra` field.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { ctrf } from 'playwright-ctrf-json-reporter'
+ *
+ * test('checkout flow', async ({ page }) => {
+ *   ctrf.extra({ owner: 'checkout-team', priority: 'P1' })
+ *   // ... test code
+ *   ctrf.extra({ customMetric: calculateValue() })
+ * })
+ * ```
+ *
+ * ## API
+ *
+ * - `ctrf.extra(data)` - Attach key-value metadata to the current test
+ *
+ * ## Behavior
+ *
+ * - Call multiple times; all data is collected and merged
+ * - Works from any function in the call stack during test execution
+ * - Silently ignored when called outside test context
+ * - Deep merge: arrays concatenate, objects merge recursively, primitives overwrite
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ctrf = exports.CTRF_RUNTIME_MESSAGE_CONTENT_TYPE = void 0;
+exports.extra = extra;
+const test_1 = require("@playwright/test");
+/**
+ * Content type used to identify CTRF runtime messages in attachments.
+ * The reporter will look for attachments with this content type.
+ */
+exports.CTRF_RUNTIME_MESSAGE_CONTENT_TYPE = 'application/vnd.ctrf.message+json';
+/**
+ * Silent fallback when no test is active - prevents errors in setup/teardown code.
+ */
+const nullTransport = {
+    send: () => __awaiter(void 0, void 0, void 0, function* () {
+        /* intentionally empty */
+    }),
+};
+/**
+ * Attaches metadata payloads to the current Playwright test as hidden attachments.
+ * The reporter extracts these by content type during report generation.
+ */
+function createPlaywrightTransport() {
+    let sequence = 0;
+    return {
+        send(payload) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const tag = `__ctrf_${++sequence}_${Date.now()}`;
+                const data = JSON.stringify(payload);
+                yield test_1.test.info().attach(tag, {
+                    contentType: exports.CTRF_RUNTIME_MESSAGE_CONTENT_TYPE,
+                    body: Buffer.from(data),
+                });
+            });
+        },
+    };
+}
+const activeTransport = createPlaywrightTransport();
+/**
+ * Resolves the active transport, or a null transport if outside a test.
+ */
+const resolveTransport = () => {
+    try {
+        test_1.test.info();
+        return activeTransport;
+    }
+    catch (_a) {
+        // Outside test context
+    }
+    return nullTransport;
+};
+/* ═══════════════════════════════════════════════════════════════════════════
+ * Public API
+ * ═══════════════════════════════════════════════════════════════════════════ */
+/**
+ * Attach custom metadata to the current test.
+ *
+ * @param data - Key-value pairs to include in the CTRF report's `extra` field
+ * @returns Promise (can be ignored; completes when attachment is written)
+ *
+ * @remarks
+ * - **Arrays**: Concatenated across calls (duplicates allowed)
+ * - **Objects**: Deep merged (nested keys preserved)
+ * - **Primitives**: Later calls overwrite earlier ones
+ * - Safe to call from helper functions - binds to the active test automatically
+ * - No-op outside test context (e.g., in global setup)
+ *
+ * @example
+ * // Arrays concatenate
+ * ctrf.extra({ tags: ['smoke'] })
+ * ctrf.extra({ tags: ['e2e'] })
+ * // → { tags: ['smoke', 'e2e'] }
+ *
+ * // Objects merge deeply
+ * ctrf.extra({ build: { id: 'abc' } })
+ * ctrf.extra({ build: { url: 'https://...' } })
+ * // → { build: { id: 'abc', url: 'https://...' } }
+ *
+ * // Primitives overwrite
+ * ctrf.extra({ owner: 'platform-team' })
+ * ctrf.extra({ owner: 'checkout-team' })
+ * // → { owner: 'checkout-team' }
+ */
+function extra(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield resolveTransport().send({ type: 'metadata', data });
+    });
+}
+/** CTRF runtime API namespace */
+exports.ctrf = { extra };

package/dist/generate-report.d.ts

@@ -43,6 +43,29 @@ declare class GenerateCtrfReport implements Reporter {
     setEnvironmentDetails(reporterConfigOptions: ReporterConfigOptions): void;
     hasEnvironmentDetails(environment: CtrfEnvironment): boolean;
     extractMetadata(testResult: TestResult): any;
+    /**
+     * Deep merge with array concatenation.
+     * Arrays are concatenated, objects are recursively merged, primitives overwrite.
+     */
+    private deepMerge;
+    /**
+     * Extract and merge runtime data from CTRF message attachments.
+     *
+     * Runtime messages are internal transport artifacts used to send data from
+     * test code to the reporter via test.info().attach(). They are identified
+     * by the CTRF_RUNTIME_MESSAGE_CONTENT_TYPE content type.
+     *
+     * ## Merge Semantics (deep merge with array concatenation)
+     *
+     * Messages are processed in attachment order with intelligent merging:
+     * - Arrays: Concatenated across calls (duplicates allowed)
+     * - Objects: Deep merged (nested keys preserved)
+     * - Primitives: Later values overwrite earlier ones
+     *
+     * @param testResult - The test result containing attachments
+     * @returns Merged runtime data or null if no CTRF messages found
+     */
+    extractRuntimeData(testResult: TestResult): Record<string, unknown> | null;
     updateStart(startTime: Date): number;
     calculateStopTime(startTime: Date, duration: number): number;
     buildSuitePath(test: TestCase): string;
@@ -51,6 +74,16 @@ declare class GenerateCtrfReport implements Reporter {
     countSuites(suite: Suite): number;
     writeReportToFile(data: CtrfReport): void;
     processStep(test: CtrfTest, step: TestStep): void;
+    /**
+     * Filter attachments to include in CTRF output.
+     *
+     * Excludes:
+     * - Attachments without a file path (body-only attachments)
+     * - CTRF runtime message attachments (internal transport artifacts)
+     *
+     * Runtime messages exist only to transmit data from test → reporter and
+     * are not user-facing attachments.
+     */
     filterValidAttachments(attachments: TestResult['attachments']): CtrfAttachment[];
 }
 export default GenerateCtrfReport;

package/dist/generate-report.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const crypto_1 = __importDefault(require("crypto"));
+const adapter_1 = require("./adapter");
 class GenerateCtrfReport {
     constructor(config) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
@@ -152,6 +153,10 @@ class GenerateCtrfReport {
             if (this.reporterConfigOptions.annotations !== undefined) {
                 test.extra = { annotations: testCase.annotations };
             }
+            const runtimeData = this.extractRuntimeData(testResult);
+            if (runtimeData !== null) {
+                test.extra = Object.assign(Object.assign({}, test.extra), runtimeData);
+            }
             if (testCase.results.length > 1) {
                 const retryResults = testCase.results.slice(0, -1);
                 test.retryAttempts = [];
@@ -259,6 +264,77 @@ class GenerateCtrfReport {
         }
         return null;
     }
+    /**
+     * Deep merge with array concatenation.
+     * Arrays are concatenated, objects are recursively merged, primitives overwrite.
+     */
+    deepMerge(target, source) {
+        const result = Object.assign({}, target);
+        for (const [key, sourceValue] of Object.entries(source)) {
+            const targetValue = result[key];
+            if (Array.isArray(sourceValue)) {
+                result[key] = Array.isArray(targetValue)
+                    ? [...targetValue, ...sourceValue]
+                    : [...sourceValue];
+            }
+            else if (sourceValue !== null &&
+                typeof sourceValue === 'object' &&
+                !Array.isArray(sourceValue)) {
+                result[key] =
+                    targetValue !== null &&
+                        typeof targetValue === 'object' &&
+                        !Array.isArray(targetValue)
+                        ? this.deepMerge(targetValue, sourceValue)
+                        : Object.assign({}, sourceValue);
+            }
+            else {
+                result[key] = sourceValue;
+            }
+        }
+        return result;
+    }
+    /**
+     * Extract and merge runtime data from CTRF message attachments.
+     *
+     * Runtime messages are internal transport artifacts used to send data from
+     * test code to the reporter via test.info().attach(). They are identified
+     * by the CTRF_RUNTIME_MESSAGE_CONTENT_TYPE content type.
+     *
+     * ## Merge Semantics (deep merge with array concatenation)
+     *
+     * Messages are processed in attachment order with intelligent merging:
+     * - Arrays: Concatenated across calls (duplicates allowed)
+     * - Objects: Deep merged (nested keys preserved)
+     * - Primitives: Later values overwrite earlier ones
+     *
+     * @param testResult - The test result containing attachments
+     * @returns Merged runtime data or null if no CTRF messages found
+     */
+    extractRuntimeData(testResult) {
+        const runtimeData = {};
+        let hasData = false;
+        for (const attachment of testResult.attachments) {
+            if (attachment.contentType !== adapter_1.CTRF_RUNTIME_MESSAGE_CONTENT_TYPE) {
+                continue;
+            }
+            if (attachment.body === undefined) {
+                continue;
+            }
+            try {
+                const message = JSON.parse(attachment.body.toString('utf-8'));
+                if (message.type === 'metadata' && message.data !== null) {
+                    Object.assign(runtimeData, this.deepMerge(runtimeData, message.data));
+                    hasData = true;
+                }
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    console.error(`Error parsing CTRF runtime message: ${e.message}`);
+                }
+            }
+        }
+        return hasData ? runtimeData : null;
+    }
     updateStart(startTime) {
         const date = new Date(startTime);
         const unixEpochTime = Math.floor(date.getTime() / 1000);
@@ -344,9 +420,27 @@ class GenerateCtrfReport {
             });
         }
     }
+    /**
+     * Filter attachments to include in CTRF output.
+     *
+     * Excludes:
+     * - Attachments without a file path (body-only attachments)
+     * - CTRF runtime message attachments (internal transport artifacts)
+     *
+     * Runtime messages exist only to transmit data from test → reporter and
+     * are not user-facing attachments.
+     */
     filterValidAttachments(attachments) {
         return attachments
-            .filter((attachment) => attachment.path !== undefined)
+            .filter((attachment) => {
+            if (attachment.path === undefined) {
+                return false;
+            }
+            if (attachment.contentType === adapter_1.CTRF_RUNTIME_MESSAGE_CONTENT_TYPE) {
+                return false;
+            }
+            return true;
+        })
             .map((attachment) => {
             var _a;
             return ({

package/dist/generate-report.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for GenerateCtrfReport deep merge functionality
+ */
+export {};

package/dist/generate-report.test.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * Unit tests for GenerateCtrfReport deep merge functionality
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generate_report_1 = __importDefault(require("./generate-report"));
+describe('GenerateCtrfReport', () => {
+    describe('deepMerge', () => {
+        let reporter;
+        beforeEach(() => {
+            reporter = new generate_report_1.default();
+        });
+        it('should concatenate arrays', () => {
+            const target = { tags: ['smoke'] };
+            const source = { tags: ['e2e'] };
+            // @ts-expect-error - accessing private method for testing
+            const result = reporter.deepMerge(target, source);
+            expect(result).toEqual({ tags: ['smoke', 'e2e'] });
+        });
+        it('should concatenate arrays from empty target', () => {
+            const target = {};
+            const source = { tags: ['smoke'] };
+            // @ts-expect-error - accessing private method for testing
+            const result = reporter.deepMerge(target, source);
+            expect(result).toEqual({ tags: ['smoke'] });
+        });
+        it('should merge objects deeply', () => {
+            const target = { build: { id: '123' } };
+            const source = { build: { branch: 'main' } };
+            // @ts-expect-error - accessing private method for testing
+            const result = reporter.deepMerge(target, source);
+            expect(result).toEqual({ build: { id: '123', branch: 'main' } });
+        });
+        it('should merge nested objects deeply', () => {
+            const target = { meta: { build: { id: '123' } } };
+            const source = { meta: { build: { url: 'https://...' } } };
+            // @ts-expect-error - accessing private method for testing
+            const result = reporter.deepMerge(target, source);
+            expect(result).toEqual({
+                meta: { build: { id: '123', url: 'https://...' } },
+            });
+        });
+        it('should overwrite primitives', () => {
+            const target = { owner: 'platform-team' };
+            const source = { owner: 'checkout-team' };
+            // @ts-expect-error - accessing private method for testing
+            const result = reporter.deepMerge(target, source);
+            expect(result).toEqual({ owner: 'checkout-team' });
+        });
+        it('should preserve non-overlapping keys', () => {
+            const target = { owner: 'platform-team', priority: 'P1' };
+            const source = { retries: 3 };
+            // @ts-expect-error - accessing private method for testing
+            const result = reporter.deepMerge(target, source);
+            expect(result).toEqual({
+                owner: 'platform-team',
+                priority: 'P1',
+                retries: 3,
+            });
+        });
+        it('should handle complex nested structures', () => {
+            const target = {
+                tags: ['smoke'],
+                build: { id: '123', metadata: { author: 'alice' } },
+                retries: 1,
+            };
+            const source = {
+                tags: ['e2e', 'regression'],
+                build: { branch: 'main', metadata: { timestamp: '2026-02-06' } },
+                retries: 2,
+                owner: 'platform',
+            };
+            // @ts-expect-error - accessing private method for testing
+            const result = reporter.deepMerge(target, source);
+            expect(result).toEqual({
+                tags: ['smoke', 'e2e', 'regression'],
+                build: {
+                    id: '123',
+                    branch: 'main',
+                    metadata: { author: 'alice', timestamp: '2026-02-06' },
+                },
+                retries: 2,
+                owner: 'platform',
+            });
+        });
+        it('should replace object with primitive', () => {
+            const target = { config: { timeout: 5000 } };
+            const source = { config: 'default' };
+            // @ts-expect-error - accessing private method for testing
+            const result = reporter.deepMerge(target, source);
+            expect(result).toEqual({ config: 'default' });
+        });
+        it('should replace primitive with object', () => {
+            const target = { config: 'default' };
+            const source = { config: { timeout: 5000 } };
+            // @ts-expect-error - accessing private method for testing
+            const result = reporter.deepMerge(target, source);
+            expect(result).toEqual({ config: { timeout: 5000 } });
+        });
+        it('should replace primitive with array', () => {
+            const target = { tags: 'smoke' };
+            const source = { tags: ['e2e'] };
+            // @ts-expect-error - accessing private method for testing
+            const result = reporter.deepMerge(target, source);
+            expect(result).toEqual({ tags: ['e2e'] });
+        });
+        it('should handle null values', () => {
+            const target = { value: null };
+            const source = { value: 'something' };
+            // @ts-expect-error - accessing private method for testing
+            const result = reporter.deepMerge(target, source);
+            expect(result).toEqual({ value: 'something' });
+        });
+        it('should handle empty objects', () => {
+            const target = {};
+            const source = { owner: 'platform' };
+            // @ts-expect-error - accessing private method for testing
+            const result = reporter.deepMerge(target, source);
+            expect(result).toEqual({ owner: 'platform' });
+        });
+        it('should not mutate original objects', () => {
+            const target = { tags: ['smoke'], build: { id: '123' } };
+            const source = { tags: ['e2e'], build: { branch: 'main' } };
+            // @ts-expect-error - accessing private method for testing
+            reporter.deepMerge(target, source);
+            expect(target).toEqual({ tags: ['smoke'], build: { id: '123' } });
+            expect(source).toEqual({ tags: ['e2e'], build: { branch: 'main' } });
+        });
+    });
+});

package/dist/index.d.ts

@@ -1 +1,2 @@
 export { default } from './generate-report';
+export { ctrf, extra } from './adapter';

package/dist/index.js

@@ -3,6 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = void 0;
+exports.extra = exports.ctrf = exports.default = void 0;
 var generate_report_1 = require("./generate-report");
 Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(generate_report_1).default; } });
+var adapter_1 = require("./adapter");
+Object.defineProperty(exports, "ctrf", { enumerable: true, get: function () { return adapter_1.ctrf; } });
+Object.defineProperty(exports, "extra", { enumerable: true, get: function () { return adapter_1.extra; } });

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "playwright-ctrf-json-reporter",
-  "version": "0.0.27",
+  "version": "0.0.28-next-1",
   "description": "A Playwright JSON test reporter to create test results reports",
   "main": "dist/index.js",
   "scripts": {
     "build": "tsc",
     "test": "jest",
-    "lint": "eslint . --ext .ts --fix",
-    "lint-check": "eslint . --ext .ts",
+    "lint": "eslint . --fix",
+    "lint:check": "eslint .",
     "format": "prettier --write .",
-    "format-check": "prettier --check .",
-    "all": "npm run lint && npm run format-check && npm run test && npm run build"
+    "format:check": "prettier --check .",
+    "all": "npm run lint && npm run format:check && npm run test && npm run build"
   },
   "repository": {
     "type": "git",
@@ -25,23 +25,43 @@
     "dist/",
     "README.md"
   ],
-  "author": "Matthew Thomas",
+  "author": "Matthew Poulton-White",
   "license": "MIT",
+  "keywords": [
+    "ctrf",
+    "common-test-report-format",
+    "test-reporting",
+    "test-results",
+    "testing",
+    "json",
+    "ci",
+    "playwright",
+    "playwright-reporter"
+  ],
+  "security": {
+    "email": "security@ctrf.io",
+    "url": "https://github.com/ctrf-io/.github/blob/main/SECURITY.md"
+  },
   "devDependencies": {
-    "@playwright/test": "^1.55.0",
-    "@types/jest": "^29.5.6",
-    "@types/node": "^20.8.7",
-    "@typescript-eslint/eslint-plugin": "^6.12.0",
-    "eslint": "^8.54.0",
-    "eslint-config-prettier": "^9.0.0",
-    "eslint-config-standard-with-typescript": "^40.0.0",
-    "eslint-plugin-import": "^2.29.0",
-    "eslint-plugin-n": "^16.3.1",
-    "eslint-plugin-prettier": "^5.0.1",
-    "eslint-plugin-promise": "^6.1.1",
-    "jest": "^29.7.0",
-    "prettier": "^3.1.0",
-    "ts-jest": "^29.1.1",
-    "typescript": "^5.3.2"
+    "@playwright/test": "^1.58.2",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.2.2",
+    "@typescript-eslint/eslint-plugin": "^8.55.0",
+    "@typescript-eslint/parser": "^8.55.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-n": "^17.23.2",
+    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-promise": "^7.2.1",
+    "jest": "^30.2.0",
+    "jest-ctrf-json-reporter": "^0.0.10",
+    "prettier": "^3.8.1",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.55.0"
+  },
+  "dependencies": {
+    "ctrf": "^0.2.0-next-0"
   }
 }