testit-adapter-cypress 3.7.5

package/dist/browser/lifecycle.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completeSpecAsync = exports.flushRuntimeMessages = exports.throwAfterSpecCompletion = exports.completeSpecOnAfterHookFailure = exports.completeSpecIfNoAfterHookLeft = exports.reportScreenshot = exports.reportTestEnd = exports.reportTestSkip = exports.completeHookErrorReporting = exports.reportTestOrHookFail = exports.reportTestPass = exports.reportStepStop = exports.reportStepStart = exports.reportTestStart = exports.reportHookEnd = exports.reportHookStart = exports.reportSuiteEnd = exports.reportSuiteStart = exports.reportRunStart = void 0;
+const types_js_1 = require("./types.js");
+const runtime_js_1 = require("./runtime.js");
+const state_js_1 = require("./state.js");
+const steps_js_1 = require("./steps.js");
+const utils_js_1 = require("./utils.js");
+const status_js_1 = require("../models/status.js");
+const reportRunStart = () => {
+    (0, state_js_1.enqueueRuntimeMessage)({
+        type: "cypress_run_start",
+        data: {},
+    });
+};
+exports.reportRunStart = reportRunStart;
+const reportSuiteStart = (suite) => {
+    (0, state_js_1.enqueueRuntimeMessage)({
+        type: "cypress_suite_start",
+        data: {
+            id: suite.id,
+            name: suite.title,
+            root: suite.root,
+            start: Date.now(),
+        },
+    });
+};
+exports.reportSuiteStart = reportSuiteStart;
+const reportSuiteEnd = (suite) => {
+    (0, state_js_1.enqueueRuntimeMessage)({
+        type: "cypress_suite_end",
+        data: {
+            root: suite.root,
+            stop: Date.now(),
+        },
+    });
+};
+exports.reportSuiteEnd = reportSuiteEnd;
+const reportHookStart = (hook, start) => {
+    (0, state_js_1.enqueueRuntimeMessage)({
+        type: "cypress_hook_start",
+        data: {
+            name: hook.title,
+            scopeType: hook.hookName.includes("each") ? "each" : "all",
+            position: hook.hookName.includes("before") ? "before" : "after",
+            start: start ?? Date.now(),
+        },
+    });
+};
+exports.reportHookStart = reportHookStart;
+const reportHookEnd = (hook) => {
+    (0, steps_js_1.finalizeSteps)();
+    (0, state_js_1.enqueueRuntimeMessage)({
+        type: "cypress_hook_end",
+        data: {
+            duration: hook.duration ?? 0,
+        },
+    });
+};
+exports.reportHookEnd = reportHookEnd;
+const reportTestStart = (test) => {
+    (0, state_js_1.setCurrentTest)(test);
+    (0, state_js_1.enqueueRuntimeMessage)({
+        type: "cypress_test_start",
+        data: (0, utils_js_1.getTestStartData)(test),
+    });
+    (0, utils_js_1.markTestAsReported)(test);
+};
+exports.reportTestStart = reportTestStart;
+const reportStepStart = (id, name) => {
+    (0, state_js_1.enqueueRuntimeMessage)({
+        type: "cypress_step_start",
+        data: {
+            id,
+            name,
+            start: Date.now(),
+        },
+    });
+};
+exports.reportStepStart = reportStepStart;
+const reportStepStop = (step, status, statusDetails) => {
+    (0, state_js_1.enqueueRuntimeMessage)({
+        type: "cypress_step_stop",
+        data: (0, utils_js_1.getStepStopData)(step, status, statusDetails),
+    });
+};
+exports.reportStepStop = reportStepStop;
+const reportTestPass = () => {
+    (0, state_js_1.enqueueRuntimeMessage)({
+        type: "cypress_test_pass",
+        data: {},
+    });
+};
+exports.reportTestPass = reportTestPass;
+const reportTestOrHookFail = (err) => {
+    const status = status_js_1.Status.FAILED;
+    const statusDetails = (0, utils_js_1.getMessageAndTraceFromError)(err);
+    (0, steps_js_1.stopAllSteps)(status, statusDetails);
+    (0, state_js_1.enqueueRuntimeMessage)({
+        type: "cypress_fail",
+        data: {
+            status,
+            statusDetails,
+        },
+    });
+};
+exports.reportTestOrHookFail = reportTestOrHookFail;
+const completeHookErrorReporting = (hook, err) => {
+    const isEachHook = hook.hookName.includes("each");
+    const suite = hook.parent;
+    const testFailData = (0, utils_js_1.getStatusDataOfTestSkippedByHookError)(hook.title, isEachHook, err, suite);
+    // Cypress doens't emit 'hook end' if the hook has failed.
+    (0, exports.reportHookEnd)(hook);
+    // Cypress doens't emit 'test end' if the hook has failed.
+    // We must report the test's end manualy in case of a 'before each' hook.
+    reportCurrentTestIfAny();
+    // Cypress skips the remaining tests in the suite of a failed hook.
+    // We should include them to the report manually.
+    reportRemainingTests(suite, testFailData);
+};
+exports.completeHookErrorReporting = completeHookErrorReporting;
+const reportTestSkip = (test) => {
+    if ((0, utils_js_1.isTestReported)(test)) {
+        (0, steps_js_1.stopAllSteps)(status_js_1.Status.SKIPPED, {
+            message: "The test was skipped before the command was completed",
+        });
+    }
+    else {
+        (0, exports.reportTestStart)(test);
+    }
+    (0, state_js_1.enqueueRuntimeMessage)({
+        type: "cypress_test_skip",
+        data: (0, utils_js_1.getTestSkipData)(),
+    });
+};
+exports.reportTestSkip = reportTestSkip;
+const reportTestEnd = (test) => {
+    (0, steps_js_1.finalizeSteps)();
+    (0, state_js_1.enqueueRuntimeMessage)({
+        type: "cypress_test_end",
+        data: {
+            duration: test.duration ?? 0,
+            retries: test._retries ?? 0,
+        },
+    });
+    (0, state_js_1.dropCurrentTest)();
+};
+exports.reportTestEnd = reportTestEnd;
+const reportScreenshot = (path, name) => {
+    (0, state_js_1.enqueueRuntimeMessage)({
+        type: "attachment_path",
+        data: { path, name, contentType: types_js_1.ContentType.PNG },
+    });
+};
+exports.reportScreenshot = reportScreenshot;
+const completeSpecIfNoAfterHookLeft = (context) => {
+    if ((0, utils_js_1.isLastRootAfterHook)(context)) {
+        const hook = context.test;
+        if (!(0, utils_js_1.isTmsHook)(hook)) {
+            (0, exports.reportHookEnd)(hook);
+        }
+        return (0, exports.completeSpecAsync)();
+    }
+};
+exports.completeSpecIfNoAfterHookLeft = completeSpecIfNoAfterHookLeft;
+const completeSpecOnAfterHookFailure = (context, hookError) => {
+    try {
+        (0, exports.reportTestOrHookFail)(hookError);
+        (0, exports.completeHookErrorReporting)(context.test, hookError);
+        // cy.task's then doesn't have onrejected, that's why we don't log async errors here.
+        return (0, exports.completeSpecAsync)();
+    }
+    catch (e) {
+        logTmsRootAfterError(context, e);
+    }
+};
+exports.completeSpecOnAfterHookFailure = completeSpecOnAfterHookFailure;
+const throwAfterSpecCompletion = (context, err) => {
+    const chain = (0, exports.completeSpecOnAfterHookFailure)(context, err)?.then(() => {
+        throw err;
+    });
+    if (!chain) {
+        throw err;
+    }
+};
+exports.throwAfterSpecCompletion = throwAfterSpecCompletion;
+const flushRuntimeMessages = () => (0, runtime_js_1.getTestRuntime)().flushTmsMessagesToTask("reportTmsCypressSpecMessages");
+exports.flushRuntimeMessages = flushRuntimeMessages;
+const completeSpecAsync = () => (0, runtime_js_1.getTestRuntime)().flushTmsMessagesToTaskAsync("reportFinalTmsCypressSpecMessages");
+exports.completeSpecAsync = completeSpecAsync;
+const reportCurrentTestIfAny = () => {
+    const currentTest = (0, state_js_1.getCurrentTest)();
+    if (currentTest) {
+        (0, exports.reportTestEnd)(currentTest);
+        (0, utils_js_1.markTestAsReported)(currentTest);
+    }
+};
+const reportRemainingTests = (suite, testFailData) => {
+    for (const test of (0, utils_js_1.iterateTests)(suite)) {
+        // Some tests in the suite might've been already reported (e.g. current test got test_end above).
+        if (!(0, utils_js_1.isTestReported)(test)) {
+            reportTestsSkippedByHookError(test, test.pending ? { ...(0, utils_js_1.getTestSkipData)(), status: status_js_1.Status.SKIPPED } : testFailData);
+        }
+    }
+};
+const reportTestsSkippedByHookError = (test, testFailData) => {
+    (0, state_js_1.enqueueRuntimeMessage)({
+        type: "cypress_skipped_test",
+        data: {
+            ...(0, utils_js_1.getTestStartData)(test),
+            ...testFailData,
+            ...(0, utils_js_1.getTestStopData)(test),
+            suites: (0, utils_js_1.getSuitePath)(test).map((s) => s.id),
+        },
+    });
+    (0, utils_js_1.markTestAsReported)(test);
+};
+const logTmsRootAfterError = (context, err) => {
+    // We play safe and swallow errors here to keep the original 'after all' error.
+    try {
+        // eslint-disable-next-line no-console
+        console.error(`Unexpected error when reporting the failure of ${context.test?.title ?? "'after all'"}`);
+        // eslint-disable-next-line no-console
+        console.error(err);
+    }
+    catch { }
+};

package/dist/browser/patching.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Patches the `after` function, to inject reporting of spec-level
+ * `after` hooks defined by the user.
+ */
+export declare const enableScopeLevelAfterHookReporting: () => void;

package/dist/browser/patching.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableScopeLevelAfterHookReporting = void 0;
+const lifecycle_js_1 = require("./lifecycle.js");
+const utils_js_1 = require("./utils.js");
+/**
+ * Patches the `after` function, to inject reporting of spec-level
+ * `after` hooks defined by the user.
+ */
+const enableScopeLevelAfterHookReporting = () => {
+    const suiteDepthCounter = createSuiteDepthCounterState();
+    patchDescribe(suiteDepthCounter);
+    patchAfter(suiteDepthCounter);
+};
+exports.enableScopeLevelAfterHookReporting = enableScopeLevelAfterHookReporting;
+const createSuiteDepthCounterState = () => {
+    let suiteDepth = 0;
+    return {
+        getSuiteDepth: () => suiteDepth,
+        incrementSuiteDepth: () => {
+            suiteDepth++;
+        },
+        decrementSuiteDepth: () => {
+            suiteDepth--;
+        },
+    };
+};
+const patchDescribe = ({ incrementSuiteDepth, decrementSuiteDepth }) => {
+    const patchDescribeFn = (target) => (title, configOrFn, fn) => {
+        incrementSuiteDepth();
+        try {
+            return forwardDescribeCall(target, title, configOrFn, fn);
+        }
+        finally {
+            decrementSuiteDepth();
+        }
+    };
+    const originalDescribeFn = globalThis.describe;
+    const patchedDescribe = patchDescribeFn(originalDescribeFn);
+    patchedDescribe.only = patchDescribeFn(originalDescribeFn.only);
+    patchedDescribe.skip = patchDescribeFn(originalDescribeFn.skip);
+    globalThis.describe = patchedDescribe;
+};
+const patchAfter = ({ getSuiteDepth }) => {
+    const originalAfter = globalThis.after;
+    const patchedAfter = (nameOrFn, fn) => {
+        return typeof nameOrFn === "string"
+            ? originalAfter(nameOrFn, wrapRootAfterFn(getSuiteDepth, fn))
+            : originalAfter(wrapRootAfterFn(getSuiteDepth, nameOrFn));
+    };
+    globalThis.after = patchedAfter;
+};
+const forwardDescribeCall = (target, ...args) => {
+    const [title, configOrFn, fn] = args;
+    if (typeof fn === "undefined" && typeof configOrFn === "undefined") {
+        return target(title);
+    }
+    else if (typeof configOrFn === "function") {
+        return target(title, configOrFn);
+    }
+    else {
+        return target(title, configOrFn, fn);
+    }
+};
+const wrapRootAfterFn = (getSuiteDepth, fn) => {
+    if (getSuiteDepth() === 0 && fn) {
+        const wrappedFn = fn.length ? wrapAfterFnWithCallback(fn) : wrapAfterFnWithoutArgs(fn);
+        Object.defineProperty(wrappedFn, "name", { value: fn.name });
+        return wrappedFn;
+    }
+    return fn;
+};
+const wrapAfterFnWithCallback = (fn) => {
+    return function (done) {
+        const wrappedDone = (hookError) => {
+            if (hookError) {
+                if (!(0, lifecycle_js_1.completeSpecOnAfterHookFailure)(this, hookError)?.then(() => done(hookError))) {
+                    done(hookError);
+                }
+                return;
+            }
+            try {
+                if ((0, lifecycle_js_1.completeSpecIfNoAfterHookLeft)(this)?.then(() => done())) {
+                    return;
+                }
+            }
+            catch (e) {
+                done(e);
+                return;
+            }
+            done();
+        };
+        return fn.bind(this)(wrappedDone);
+    };
+};
+const wrapAfterFnWithoutArgs = (fn) => {
+    return function () {
+        let result;
+        let syncError;
+        try {
+            result = fn.bind(this)();
+        }
+        catch (e) {
+            syncError = e;
+        }
+        if (syncError) {
+            (0, lifecycle_js_1.throwAfterSpecCompletion)(this, syncError);
+        }
+        else if ((0, utils_js_1.isPromise)(result)) {
+            return result.then(() => (0, lifecycle_js_1.completeSpecIfNoAfterHookLeft)(this), (asyncError) => (0, lifecycle_js_1.throwAfterSpecCompletion)(this, asyncError));
+        }
+        else {
+            (0, lifecycle_js_1.completeSpecIfNoAfterHookLeft)(this);
+            return result;
+        }
+    };
+};

package/dist/browser/runtime.d.ts

@@ -0,0 +1,31 @@
+import { Label, Link, Status } from "testit-js-commons";
+import type { AttachmentOptions, TestRuntime } from "./types.js";
+import type { StatusDetails } from "../models/types.js";
+export declare const initTestRuntime: () => void;
+export declare const getTestRuntime: () => TmsCypressTestRuntime;
+declare class TmsCypressTestRuntime implements TestRuntime {
+    #private;
+    constructor();
+    addLabels(...labels: Label[]): PromiseLike<void>;
+    addTags(...tags: string[]): PromiseLike<void>;
+    addLinks(...links: Link[]): PromiseLike<void>;
+    addWorkItemIds(...workItemIds: string[]): PromiseLike<void>;
+    addParameter(name: string, value: string): PromiseLike<void>;
+    addDescription(markdown: string): PromiseLike<void>;
+    addTitle(markdown: string): PromiseLike<void>;
+    addDisplayName(name: string): PromiseLike<void>;
+    addNameSpace(name: string): PromiseLike<void>;
+    addClassName(name: string): PromiseLike<void>;
+    addAttachments(name: string, content: Buffer | string, options: AttachmentOptions): PromiseLike<void>;
+    addAttachmentsFromPath(name: string, path: string, options: Omit<AttachmentOptions, "encoding">): PromiseLike<void>;
+    addGlobalAttachments(name: string, content: Buffer | string, options: AttachmentOptions): PromiseLike<void>;
+    addGlobalAttachmentsFromPath(name: string, path: string, options: Omit<AttachmentOptions, "encoding">): PromiseLike<void>;
+    addMessage(details: StatusDetails): PromiseLike<void>;
+    logStep(name: string, status?: Status, error?: Error): PromiseLike<void>;
+    step<T = void>(name: string, body: () => T | PromiseLike<T>): Cypress.ThenReturn<T, T>;
+    stepDisplayName(name: string): PromiseLike<void>;
+    stepParameter(name: string, value: string): PromiseLike<void>;
+    flushTmsMessagesToTask(taskName: string): void;
+    flushTmsMessagesToTaskAsync(taskName: string): Cypress.Chainable<unknown> | undefined;
+}
+export {};

package/dist/browser/runtime.js

@@ -0,0 +1,284 @@
+"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 _TmsCypressTestRuntime_instances, _TmsCypressTestRuntime_resetMessages, _TmsCypressTestRuntime_enqueueMessageAsync, _TmsCypressTestRuntime_dequeueAllMessages, _TmsCypressTestRuntime_buildAttachmentContent, _TmsCypressTestRuntime_normalizeAttachmentContent, _TmsCypressTestRuntime_isSerializedBuffer, _TmsCypressTestRuntime_isInOriginContext;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTestRuntime = exports.initTestRuntime = void 0;
+const testit_js_commons_1 = require("testit-js-commons");
+const state_js_1 = require("./state.js");
+const steps_js_1 = require("./steps.js");
+const utils_js_1 = require("./utils.js");
+const initTestRuntime = () => (0, utils_js_1.setGlobalTestRuntime)(new TmsCypressTestRuntime());
+exports.initTestRuntime = initTestRuntime;
+const getTestRuntime = () => (0, utils_js_1.getGlobalTestRuntime)();
+exports.getTestRuntime = getTestRuntime;
+class TmsCypressTestRuntime {
+    constructor() {
+        _TmsCypressTestRuntime_instances.add(this);
+        __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_resetMessages).call(this);
+    }
+    addLabels(...labels) {
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "metadata",
+            data: {
+                labels,
+            },
+        });
+    }
+    addTags(...tags) {
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "metadata",
+            data: {
+                tags,
+            },
+        });
+    }
+    addLinks(...links) {
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "metadata",
+            data: {
+                links,
+            },
+        });
+    }
+    addWorkItemIds(...workItemIds) {
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "metadata",
+            data: {
+                workItemIds,
+            },
+        });
+    }
+    addParameter(name, value) {
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "metadata",
+            data: {
+                parameters: [
+                    {
+                        name,
+                        value
+                    },
+                ],
+            },
+        });
+    }
+    addDescription(markdown) {
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "metadata",
+            data: {
+                description: markdown,
+            },
+        });
+    }
+    addTitle(markdown) {
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "metadata",
+            data: {
+                title: markdown,
+            },
+        });
+    }
+    addDisplayName(name) {
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "metadata",
+            data: {
+                displayName: name,
+            },
+        });
+    }
+    addNameSpace(name) {
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "metadata",
+            data: {
+                namespace: name,
+            },
+        });
+    }
+    addClassName(name) {
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "metadata",
+            data: {
+                classname: name,
+            },
+        });
+    }
+    addAttachments(name, content, options) {
+        const [attachmentContent, actualEncoding] = __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_buildAttachmentContent).call(this, content);
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "attachment_content",
+            data: {
+                name,
+                content: attachmentContent,
+                encoding: actualEncoding,
+                contentType: options.contentType,
+                fileExtension: options.fileExtension,
+            },
+        });
+    }
+    addAttachmentsFromPath(name, path, options) {
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "attachment_path",
+            data: {
+                name,
+                path,
+                contentType: options.contentType,
+                fileExtension: options.fileExtension,
+            },
+        });
+    }
+    addGlobalAttachments(name, content, options) {
+        const [attachmentContent, actualEncoding] = __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_buildAttachmentContent).call(this, content);
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "global_attachment_content",
+            data: {
+                name,
+                content: attachmentContent,
+                encoding: actualEncoding,
+                contentType: options.contentType,
+                fileExtension: options.fileExtension,
+            },
+        });
+    }
+    addGlobalAttachmentsFromPath(name, path, options) {
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "global_attachment_path",
+            data: {
+                name,
+                path,
+                contentType: options.contentType,
+                fileExtension: options.fileExtension,
+            },
+        });
+    }
+    addMessage(details) {
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "global_error",
+            data: details,
+        });
+    }
+    logStep(name, status = testit_js_commons_1.Status.PASSED, error) {
+        if (__classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_isInOriginContext).call(this)) {
+            (0, steps_js_1.startTmsApiStep)(name);
+            (0, steps_js_1.stopCurrentTmsApiStep)(status, error ? (0, utils_js_1.getMessageAndTraceFromError)(error) : undefined);
+            return Cypress.Promise.resolve();
+        }
+        return cy
+            .wrap(steps_js_1.TMS_STEP_CMD_SUBJECT, { log: false })
+            .then(() => {
+            (0, steps_js_1.startTmsApiStep)(name);
+            return Cypress.Promise.resolve();
+        })
+            .then(() => {
+            (0, steps_js_1.stopCurrentTmsApiStep)(status, error ? (0, utils_js_1.getMessageAndTraceFromError)(error) : undefined);
+            return Cypress.Promise.resolve();
+        });
+    }
+    step(name, body) {
+        return cy
+            .wrap(steps_js_1.TMS_STEP_CMD_SUBJECT, { log: false })
+            .then(() => {
+            (0, steps_js_1.startTmsApiStep)(name);
+            return Cypress.Promise.resolve(body());
+        })
+            .then((result) => {
+            (0, steps_js_1.stopCurrentTmsApiStep)();
+            return result;
+        });
+    }
+    stepDisplayName(name) {
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "step_metadata",
+            data: {
+                name,
+            },
+        });
+    }
+    stepParameter(name, value) {
+        return __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_enqueueMessageAsync).call(this, {
+            type: "step_metadata",
+            data: {
+                parameters: [{ name, value }],
+            },
+        });
+    }
+    flushTmsMessagesToTask(taskName) {
+        const messages = __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_dequeueAllMessages).call(this);
+        if (messages.length) {
+            cy.task(taskName, { absolutePath: Cypress.spec.absolute, messages }, { log: false });
+        }
+    }
+    flushTmsMessagesToTaskAsync(taskName) {
+        const messages = __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_dequeueAllMessages).call(this);
+        if (messages.length) {
+            const args = {
+                absolutePath: Cypress.spec.absolute,
+                messages,
+                isInteractive: Cypress.config("isInteractive"),
+            };
+            return cy.task(taskName, args, { log: false });
+        }
+    }
+}
+_TmsCypressTestRuntime_instances = new WeakSet(), _TmsCypressTestRuntime_resetMessages = function _TmsCypressTestRuntime_resetMessages() {
+    (0, state_js_1.setRuntimeMessages)([]);
+}, _TmsCypressTestRuntime_enqueueMessageAsync = function _TmsCypressTestRuntime_enqueueMessageAsync(message) {
+    (0, state_js_1.enqueueRuntimeMessage)(message);
+    return Cypress.Promise.resolve();
+}, _TmsCypressTestRuntime_dequeueAllMessages = function _TmsCypressTestRuntime_dequeueAllMessages() {
+    const messages = (0, state_js_1.getRuntimeMessages)();
+    __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_resetMessages).call(this);
+    return messages;
+}, _TmsCypressTestRuntime_buildAttachmentContent = function _TmsCypressTestRuntime_buildAttachmentContent(content) {
+    const rawContent = __classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_normalizeAttachmentContent).call(this, content);
+    const encoding = typeof rawContent === "string" ? "utf8" : "base64";
+    return [(0, utils_js_1.uint8ArrayToBase64)(rawContent), encoding];
+}, _TmsCypressTestRuntime_normalizeAttachmentContent = function _TmsCypressTestRuntime_normalizeAttachmentContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (__classPrivateFieldGet(this, _TmsCypressTestRuntime_instances, "m", _TmsCypressTestRuntime_isSerializedBuffer).call(this, content)) {
+        return new Uint8Array(content.data);
+    }
+    return content;
+}, _TmsCypressTestRuntime_isSerializedBuffer = function _TmsCypressTestRuntime_isSerializedBuffer(content) {
+    if (!content || typeof content !== "object") {
+        return false;
+    }
+    const candidate = content;
+    return candidate.type === "Buffer" && Array.isArray(candidate.data);
+}, _TmsCypressTestRuntime_isInOriginContext = function _TmsCypressTestRuntime_isInOriginContext() {
+    try {
+        const hasOriginContext = !!window.cypressOriginContext;
+        const hasOriginWindow = !!window.cypressOriginWindow;
+        if (hasOriginContext || hasOriginWindow) {
+            return true;
+        }
+        const baseUrl = Cypress.config("baseUrl");
+        const currentOrigin = window.location.origin;
+        if (baseUrl && currentOrigin !== baseUrl) {
+            return true;
+        }
+        const cypressInstance = window.Cypress;
+        if (cypressInstance && cypressInstance.state && cypressInstance.state("origin")) {
+            return true;
+        }
+        try {
+            const cyExists = typeof cy !== "undefined";
+            const cyTaskExists = typeof cy.task !== "undefined";
+            // In cy.origin context, cy.task may not be available or may throw
+            if (!cyExists || !cyTaskExists) {
+                return true;
+            }
+        }
+        catch (error) {
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        return true;
+    }
+};

package/dist/browser/serialize.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (value: unknown) => string;
+export default _default;
+export declare const serializeAsObject: (value: unknown) => string;