testit-adapter-cypress 3.7.5

package/dist/node-utils.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Helpers that use Node.js built-in modules. Import only in Node context (e.g. reporter, plugins).
+ * Do not import in browser bundle (Cypress support/specs).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectRoot = getProjectRoot;
+exports.getRelativePath = getRelativePath;
+exports.getPosixPath = getPosixPath;
+exports.parseTestPlan = parseTestPlan;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_process_1 = __importDefault(require("node:process"));
+let cachedProjectRoot = null;
+function findProjectRoot() {
+    let dir = node_process_1.default.cwd();
+    while (dir !== path.dirname(dir)) {
+        try {
+            fs.accessSync(path.join(dir, "package.json"), fs.constants.F_OK);
+            return dir;
+        }
+        catch {
+            dir = path.dirname(dir);
+        }
+    }
+    return node_process_1.default.cwd();
+}
+function getProjectRoot() {
+    if (!cachedProjectRoot)
+        cachedProjectRoot = findProjectRoot();
+    return cachedProjectRoot;
+}
+function getRelativePath(absolutePath) {
+    const root = getProjectRoot();
+    if (path.isAbsolute(absolutePath)) {
+        return path.relative(root, absolutePath);
+    }
+    return absolutePath;
+}
+function getPosixPath(filepath) {
+    return node_process_1.default.platform === "win32" ? filepath.replaceAll("\\", "/") : filepath;
+}
+function parseTestPlan() {
+    const envPath = node_process_1.default.env.TMS_TESTPLAN_PATH;
+    if (!envPath)
+        return undefined;
+    try {
+        const content = fs.readFileSync(envPath, "utf-8");
+        const plan = JSON.parse(content);
+        if (!plan.tests?.length)
+            return undefined;
+        return plan;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/reporter.d.ts

@@ -0,0 +1,24 @@
+import type { TestData, StepData } from "./converter.js";
+import type { TmsCypressConfig } from "./models/types.js";
+interface TestItSpecContext {
+    specPath: string;
+    suiteNames: string[];
+    currentTestData: TestData | null;
+    completedTests: TestData[];
+    stepsByFrontEndId: Map<string, StepData>;
+    stepStack: StepData[];
+    failed: boolean;
+}
+export declare class TmsCypress {
+    #private;
+    private strategy;
+    private additions;
+    specContextByAbsolutePath: Map<string, TestItSpecContext>;
+    videoOnFailOnly: boolean;
+    constructor(config?: TmsCypressConfig);
+    attachToCypress: (on: Cypress.PluginEvents) => void;
+    onAfterSpec: (spec: Cypress.Spec, results: CypressCommandLine.RunResult | undefined) => void;
+    endSpec: (specAbsolutePath: string, cypressVideoPath?: string) => Promise<void>;
+}
+export declare const tmsCypress: (on: Cypress.PluginEvents, cypressConfig?: Cypress.PluginConfigOptions, tmsConfig?: TmsCypressConfig) => TmsCypress;
+export {};

package/dist/reporter.js

@@ -0,0 +1,382 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TmsCypress_endAllSpecs, _TmsCypress_applySpecMessages, _TmsCypress_startRun, _TmsCypress_startSuite, _TmsCypress_stopSuite, _TmsCypress_startHook, _TmsCypress_stopHook, _TmsCypress_startTest, _TmsCypress_passTest, _TmsCypress_failTest, _TmsCypress_skipTest, _TmsCypress_addSkippedTest, _TmsCypress_stopTest, _TmsCypress_startStep, _TmsCypress_stopStep, _TmsCypress_finalizeStep, _TmsCypress_handleAttachmentPath, _TmsCypress_handleAttachmentContent, _TmsCypress_applyRuntimeMessage;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tmsCypress = exports.TmsCypress = void 0;
+const testit_js_commons_1 = require("testit-js-commons");
+const converter_js_1 = require("./converter.js");
+const utils_js_1 = require("./utils.js");
+const node_utils_js_1 = require("./node-utils.js");
+const status_js_1 = require("./models/status.js");
+class TmsCypress {
+    constructor(config = {}) {
+        this.specContextByAbsolutePath = new Map();
+        this.videoOnFailOnly = false;
+        this.attachToCypress = (on) => {
+            on("before:run", async () => {
+                await this.strategy.setup();
+            });
+            on("task", {
+                reportTmsCypressSpecMessages: async (args) => {
+                    await __classPrivateFieldGet(this, _TmsCypress_applySpecMessages, "f").call(this, args);
+                    return null;
+                },
+                reportFinalTmsCypressSpecMessages: async (args) => {
+                    await __classPrivateFieldGet(this, _TmsCypress_applySpecMessages, "f").call(this, args);
+                    if (args.isInteractive) {
+                        await this.endSpec(args.absolutePath);
+                    }
+                    return null;
+                },
+            });
+            on("after:spec", this.onAfterSpec);
+            on("after:run", async () => {
+                await __classPrivateFieldGet(this, _TmsCypress_endAllSpecs, "f").call(this);
+                await this.strategy.teardown();
+            });
+        };
+        this.onAfterSpec = (spec, results) => {
+            this.endSpec(spec.absolute, results?.video ?? undefined);
+        };
+        this.endSpec = async (specAbsolutePath, cypressVideoPath) => {
+            const context = this.specContextByAbsolutePath.get(specAbsolutePath);
+            if (!context)
+                return;
+            let videoAttachmentIds = [];
+            if ((!this.videoOnFailOnly || context.failed) && cypressVideoPath) {
+                try {
+                    const attachments = await this.additions.addAttachments([cypressVideoPath]);
+                    videoAttachmentIds = attachments.map((a) => a.id);
+                }
+                catch {
+                    // ignore
+                }
+            }
+            const posixSpecPath = (0, node_utils_js_1.getRelativePath)(specAbsolutePath).replace(/\\/g, "/");
+            const uniqueByFullName = new Map();
+            for (const t of context.completedTests) {
+                uniqueByFullName.set(t.fullNameSuffix, t);
+            }
+            for (const t of uniqueByFullName.values()) {
+                const autotest = (0, converter_js_1.toAutotestPost)(posixSpecPath, t);
+                await this.strategy.loadAutotest(autotest, t.outcome);
+                const result = (0, converter_js_1.toAutotestResult)(autotest.externalId, t, t.outcome, videoAttachmentIds);
+                await this.strategy.loadTestRun([result]);
+            }
+            this.specContextByAbsolutePath.delete(specAbsolutePath);
+        };
+        _TmsCypress_endAllSpecs.set(this, async () => {
+            for (const path of Array.from(this.specContextByAbsolutePath.keys())) {
+                await this.endSpec(path);
+            }
+        });
+        _TmsCypress_applySpecMessages.set(this, async ({ messages, absolutePath }) => {
+            if (messages.some((m) => m.type === "cypress_run_start")) {
+                __classPrivateFieldGet(this, _TmsCypress_startRun, "f").call(this, absolutePath);
+            }
+            const context = this.specContextByAbsolutePath.get(absolutePath);
+            if (!context)
+                return;
+            for (const message of messages) {
+                if (message.type === "cypress_run_start")
+                    continue;
+                switch (message.type) {
+                    case "cypress_suite_start":
+                        __classPrivateFieldGet(this, _TmsCypress_startSuite, "f").call(this, context, message.data);
+                        break;
+                    case "cypress_suite_end":
+                        __classPrivateFieldGet(this, _TmsCypress_stopSuite, "f").call(this, context, message.data);
+                        break;
+                    case "cypress_hook_start":
+                        __classPrivateFieldGet(this, _TmsCypress_startHook, "f").call(this, context, message.data);
+                        break;
+                    case "cypress_hook_end":
+                        __classPrivateFieldGet(this, _TmsCypress_stopHook, "f").call(this);
+                        break;
+                    case "cypress_test_start":
+                        __classPrivateFieldGet(this, _TmsCypress_startTest, "f").call(this, context, message.data);
+                        break;
+                    case "cypress_test_pass":
+                        __classPrivateFieldGet(this, _TmsCypress_passTest, "f").call(this, context);
+                        break;
+                    case "cypress_fail":
+                        __classPrivateFieldGet(this, _TmsCypress_failTest, "f").call(this, context, message.data);
+                        break;
+                    case "cypress_test_skip":
+                        __classPrivateFieldGet(this, _TmsCypress_skipTest, "f").call(this, context, message.data);
+                        break;
+                    case "cypress_skipped_test":
+                        __classPrivateFieldGet(this, _TmsCypress_addSkippedTest, "f").call(this, context, message.data);
+                        break;
+                    case "cypress_test_end":
+                        __classPrivateFieldGet(this, _TmsCypress_stopTest, "f").call(this, context, message.data);
+                        break;
+                    case "cypress_step_start":
+                        __classPrivateFieldGet(this, _TmsCypress_startStep, "f").call(this, context, message.data);
+                        break;
+                    case "cypress_step_stop":
+                        __classPrivateFieldGet(this, _TmsCypress_stopStep, "f").call(this, context, message.data);
+                        break;
+                    case "cypress_step_finalize":
+                        __classPrivateFieldGet(this, _TmsCypress_finalizeStep, "f").call(this, context, message.data);
+                        break;
+                    case "attachment_path":
+                        await __classPrivateFieldGet(this, _TmsCypress_handleAttachmentPath, "f").call(this, context, message.data);
+                        break;
+                    case "attachment_content":
+                        await __classPrivateFieldGet(this, _TmsCypress_handleAttachmentContent, "f").call(this, context, message.data);
+                        break;
+                    default:
+                        __classPrivateFieldGet(this, _TmsCypress_applyRuntimeMessage, "f").call(this, context, message);
+                        break;
+                }
+            }
+        });
+        _TmsCypress_startRun.set(this, (absolutePath) => {
+            const specPath = (0, node_utils_js_1.getRelativePath)(absolutePath);
+            const context = {
+                specPath,
+                suiteNames: [],
+                currentTestData: null,
+                completedTests: [],
+                stepsByFrontEndId: new Map(),
+                stepStack: [],
+                failed: false,
+            };
+            this.specContextByAbsolutePath.set(absolutePath, context);
+        });
+        _TmsCypress_startSuite.set(this, (context, data) => {
+            if (!data.root) {
+                context.suiteNames.push(data.name);
+            }
+        });
+        _TmsCypress_stopSuite.set(this, (context, data) => {
+            if (!data.root && context.suiteNames.length) {
+                context.suiteNames.pop();
+            }
+        });
+        _TmsCypress_startHook.set(this, (context, _data) => {
+            if (context.currentTestData)
+                return;
+            context.stepStack = [];
+        });
+        _TmsCypress_stopHook.set(this, () => { });
+        _TmsCypress_startTest.set(this, (context, data) => {
+            context.stepStack = [];
+            context.stepsByFrontEndId.clear();
+            context.currentTestData = {
+                displayName: data.name,
+                fullNameSuffix: data.fullNameSuffix,
+                outcome: status_js_1.Status.PASSED,
+                labels: data.labels ?? [],
+                tags: data.tags ?? [],
+                links: data.links ?? [],
+                workItemIds: data.workItemIds ?? [],
+                start: data.start,
+                steps: [],
+                attachmentIds: [],
+                externalKey: data.fullNameSuffix,
+            };
+        });
+        _TmsCypress_passTest.set(this, (context) => {
+            if (context.currentTestData)
+                context.currentTestData.outcome = status_js_1.Status.PASSED;
+        });
+        _TmsCypress_failTest.set(this, (context, data) => {
+            context.failed = true;
+            if (context.currentTestData) {
+                context.currentTestData.outcome = data.status === status_js_1.Status.SKIPPED ? status_js_1.Status.SKIPPED : status_js_1.Status.FAILED;
+                context.currentTestData.statusDetails = data.statusDetails;
+            }
+        });
+        _TmsCypress_skipTest.set(this, (context, data) => {
+            if (context.currentTestData) {
+                context.currentTestData.outcome = status_js_1.Status.SKIPPED;
+                if (data.statusDetails)
+                    context.currentTestData.statusDetails = data.statusDetails;
+            }
+        });
+        _TmsCypress_addSkippedTest.set(this, (context, data) => {
+            const alreadyAdded = context.completedTests.some((c) => c.fullNameSuffix === data.fullNameSuffix) ||
+                (context.currentTestData?.fullNameSuffix === data.fullNameSuffix);
+            if (alreadyAdded)
+                return;
+            const t = {
+                displayName: data.name,
+                fullNameSuffix: data.fullNameSuffix,
+                labels: data.labels ?? [],
+                tags: data.tags ?? [],
+                links: data.links ?? [],
+                workItemIds: data.workItemIds ?? [],
+                outcome: status_js_1.Status.SKIPPED,
+                duration: data.duration,
+                statusDetails: data.statusDetails,
+                steps: [],
+                attachmentIds: [],
+                externalKey: data.fullNameSuffix,
+            };
+            context.completedTests.push(t);
+        });
+        _TmsCypress_stopTest.set(this, (context, data) => {
+            var _a;
+            if (context.currentTestData) {
+                context.currentTestData.duration = data.duration;
+                if (context.currentTestData.start != null) {
+                    context.currentTestData.stop = context.currentTestData.start + data.duration;
+                }
+                (_a = context.currentTestData).outcome ?? (_a.outcome = status_js_1.Status.PASSED);
+                context.completedTests.push(context.currentTestData);
+                context.currentTestData = null;
+            }
+            context.stepStack = [];
+            context.stepsByFrontEndId.clear();
+        });
+        _TmsCypress_startStep.set(this, (context, data) => {
+            const step = {
+                id: data.id,
+                name: data.name,
+                start: data.start,
+                attachmentIds: [],
+                children: [],
+            };
+            context.stepsByFrontEndId.set(data.id, step);
+            if (!context.currentTestData)
+                return;
+            const parent = (0, utils_js_1.last)(context.stepStack);
+            if (parent) {
+                parent.children.push(step);
+            }
+            else {
+                context.currentTestData.steps.push(step);
+            }
+            context.stepStack.push(step);
+        });
+        _TmsCypress_stopStep.set(this, (context, data) => {
+            const step = context.stepsByFrontEndId.get(data.id);
+            if (step) {
+                step.stop = data.stop;
+                step.status = data.status;
+                step.statusDetails = data.statusDetails;
+            }
+            if (context.stepStack.length)
+                context.stepStack.pop();
+        });
+        _TmsCypress_finalizeStep.set(this, (context, data) => {
+            const step = context.stepsByFrontEndId.get(data.id);
+            if (step) {
+                if (data.name)
+                    step.name = data.name;
+                if (data.statusDetails)
+                    step.statusDetails = data.statusDetails;
+            }
+            context.stepsByFrontEndId.delete(data.id);
+        });
+        _TmsCypress_handleAttachmentPath.set(this, async (context, data) => {
+            try {
+                const attachments = await this.additions.addAttachments([data.path]);
+                const ids = attachments.map((a) => a.id);
+                const target = (0, utils_js_1.last)(context.stepStack) ?? context.currentTestData;
+                if (target)
+                    target.attachmentIds.push(...ids);
+            }
+            catch {
+                // ignore
+            }
+        });
+        _TmsCypress_handleAttachmentContent.set(this, async (context, data) => {
+            try {
+                const buffer = Buffer.from(data.content, data.encoding);
+                const attachments = await this.additions.addAttachments(buffer, data.name);
+                const ids = attachments.map((a) => a.id);
+                const target = (0, utils_js_1.last)(context.stepStack) ?? context.currentTestData;
+                if (target)
+                    target.attachmentIds.push(...ids);
+            }
+            catch {
+                // ignore
+            }
+        });
+        _TmsCypress_applyRuntimeMessage.set(this, (context, message) => {
+            if (message.type !== "metadata" || !context.currentTestData)
+                return;
+            const data = message.data;
+            const current = context.currentTestData;
+            if (data.labels?.length) {
+                current.labels.push(...data.labels);
+            }
+            if (data.tags?.length) {
+                current.tags.push(...data.tags);
+            }
+            if (data.links?.length) {
+                current.links.push(...data.links.map((l) => ({
+                    url: l.url,
+                    title: l.title ?? l.url,
+                    description: l.description,
+                })));
+            }
+            if (data.parameters?.length) {
+                current.parameters ?? (current.parameters = {});
+                for (const p of data.parameters) {
+                    current.parameters[p.name] = p.value;
+                }
+            }
+            if (data.description) {
+                current.description = data.description;
+            }
+            else if (data.descriptionHtml && !current.description) {
+                current.description = data.descriptionHtml;
+            }
+            if (data.displayName) {
+                current.displayName = data.displayName;
+            }
+            if (data.title) {
+                current.title = data.title;
+            }
+        });
+        const { videoOnFailOnly = false, ...rest } = config;
+        this.videoOnFailOnly = videoOnFailOnly;
+        const adapterConfig = rest.tmsOptions ?? rest;
+        const composed = new testit_js_commons_1.ConfigComposer().compose(adapterConfig);
+        this.strategy = testit_js_commons_1.StrategyFactory.create(composed);
+        this.additions = new testit_js_commons_1.Additions(composed);
+    }
+}
+exports.TmsCypress = TmsCypress;
+_TmsCypress_endAllSpecs = new WeakMap(), _TmsCypress_applySpecMessages = new WeakMap(), _TmsCypress_startRun = new WeakMap(), _TmsCypress_startSuite = new WeakMap(), _TmsCypress_stopSuite = new WeakMap(), _TmsCypress_startHook = new WeakMap(), _TmsCypress_stopHook = new WeakMap(), _TmsCypress_startTest = new WeakMap(), _TmsCypress_passTest = new WeakMap(), _TmsCypress_failTest = new WeakMap(), _TmsCypress_skipTest = new WeakMap(), _TmsCypress_addSkippedTest = new WeakMap(), _TmsCypress_stopTest = new WeakMap(), _TmsCypress_startStep = new WeakMap(), _TmsCypress_stopStep = new WeakMap(), _TmsCypress_finalizeStep = new WeakMap(), _TmsCypress_handleAttachmentPath = new WeakMap(), _TmsCypress_handleAttachmentContent = new WeakMap(), _TmsCypress_applyRuntimeMessage = new WeakMap();
+const getRuntimeConfigDefaults = (config = {}) => ({
+    stepsFromCommands: {
+        maxArgumentLength: config.stepsFromCommands?.maxArgumentLength ?? utils_js_1.DEFAULT_RUNTIME_CONFIG.stepsFromCommands.maxArgumentLength,
+        maxArgumentDepth: config.stepsFromCommands?.maxArgumentDepth ?? utils_js_1.DEFAULT_RUNTIME_CONFIG.stepsFromCommands.maxArgumentDepth,
+    },
+});
+const createRuntimeState = (config) => ({
+    config: getRuntimeConfigDefaults(config),
+    initialized: false,
+    messages: [],
+    testPlan: (0, node_utils_js_1.parseTestPlan)(),
+    projectDir: (0, node_utils_js_1.getProjectRoot)(),
+    stepStack: [],
+    stepsToFinalize: [],
+    nextApiStepId: 0,
+});
+const initializeRuntimeState = (cypressConfig, config) => {
+    cypressConfig.env.tms = createRuntimeState(config);
+    return cypressConfig;
+};
+const tmsCypress = (on, cypressConfig, tmsConfig) => {
+    if (!tmsConfig && cypressConfig && !("env" in cypressConfig)) {
+        tmsConfig = cypressConfig;
+    }
+    const hasCypressConfig = cypressConfig && "env" in cypressConfig;
+    const reporter = new TmsCypress(tmsConfig);
+    reporter.attachToCypress(on);
+    if (hasCypressConfig) {
+        initializeRuntimeState(cypressConfig, tmsConfig);
+    }
+    return reporter;
+};
+exports.tmsCypress = tmsCypress;

package/dist/utils.d.ts

@@ -0,0 +1,17 @@
+export declare const DEFAULT_RUNTIME_CONFIG: {
+    stepsFromCommands: {
+        maxArgumentLength: number;
+        maxArgumentDepth: number;
+    };
+};
+/**
+ * Pops items from an array into a new one. The item that matches the predicate is the last item to pop.
+ * If there is no such item in the array, the array is left unmodified.
+ * @param items An array to pop the items from.
+ * @param pred A predicate that defines the last item to pop.
+ * @returns An array of popped items. The first popped item becomes the first element of this array.
+ */
+export declare const popUntilFindIncluded: <T>(items: T[], pred: (value: T) => boolean) => T[];
+export declare const toReversed: <T = unknown>(arr: T[]) => T[];
+export declare const last: <T = unknown>(arr: T[]) => T | undefined;
+export declare const isDefined: <T>(value: T | undefined) => value is T;

package/dist/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDefined = exports.last = exports.toReversed = exports.popUntilFindIncluded = exports.DEFAULT_RUNTIME_CONFIG = void 0;
+exports.DEFAULT_RUNTIME_CONFIG = {
+    stepsFromCommands: {
+        maxArgumentLength: 128,
+        maxArgumentDepth: 3,
+    },
+};
+/**
+ * Pops items from an array into a new one. The item that matches the predicate is the last item to pop.
+ * If there is no such item in the array, the array is left unmodified.
+ * @param items An array to pop the items from.
+ * @param pred A predicate that defines the last item to pop.
+ * @returns An array of popped items. The first popped item becomes the first element of this array.
+ */
+const popUntilFindIncluded = (items, pred) => {
+    const index = items.findIndex(pred);
+    return index !== -1 ? (0, exports.toReversed)(items.splice(index)) : [];
+};
+exports.popUntilFindIncluded = popUntilFindIncluded;
+const toReversed = (arr) => {
+    const len = arr.length;
+    const result = new Array(len);
+    for (let i = 0; i < len; i++) {
+        result[len - i - 1] = arr[i];
+    }
+    return result;
+};
+exports.toReversed = toReversed;
+const last = (arr) => arr[arr.length - 1];
+exports.last = last;
+const isDefined = (value) => typeof value !== "undefined";
+exports.isDefined = isDefined;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "testit-adapter-cypress",
+  "version": "3.7.5",
+  "description": "Cypress adapter for Test IT",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Integration team",
+    "email": "integrations@testit.software"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/testit-tms/adapters-js.git"
+  },
+  "keywords": [],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./reporter": {
+      "types": "./dist/reporter.d.ts",
+      "default": "./dist/reporter.js"
+    },
+    "./runtime": {
+      "types": "./dist/browser/runtime.d.ts",
+      "default": "./dist/browser/runtime.js"
+    }
+  },
+  "scripts": {
+    "clean": "rimraf ./dist ./out",
+    "prebuild": "npm --prefix ../testit-js-commons run build && npm link ../testit-js-commons",
+    "build": "tsc -p tsconfig.json"
+  },
+  "devDependencies": {
+    "cypress": "14.2.0",
+    "typescript": "^5.2.2",
+    "esbuild": "^0.27.0",
+    "eslint": "^8.57.0",
+    "@types/eslint": "^8.56.11",
+    "@types/node": "^20.14.2"
+  },
+  "dependencies": {
+    "testit-js-commons": "3.7.5"
+  },
+  "files": [
+    "dist"
+  ]
+}