@empiricalrun/playwright-utils 0.6.3 → 0.7.0

package/dist/reporter/custom.js

@@ -0,0 +1,699 @@
+"use strict";
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * 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.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startHtmlReportServer = exports.showHTMLReport = void 0;
+const code_frame_1 = require("@babel/code-frame");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("playwright-core/lib/utils");
+// @ts-ignore
+const utilsBundle_1 = require("playwright-core/lib/utilsBundle");
+// @ts-ignore
+const zipBundle_1 = require("playwright-core/lib/zipBundle");
+const stream_1 = require("stream");
+const base_1 = require("./base");
+const upload_1 = require("./upload");
+const util_1 = require("./util");
+const htmlReportOptions = ["always", "never", "on-failure"];
+const isHtmlReportOption = (type) => {
+    return htmlReportOptions.includes(type);
+};
+class HtmlReporter {
+    config;
+    suite;
+    _options;
+    _outputFolder;
+    _attachmentsBaseURL;
+    _open;
+    _port;
+    _host;
+    _buildResult;
+    _topLevelErrors = [];
+    constructor(options) {
+        this._options = options;
+    }
+    printsToStdio() {
+        return false;
+    }
+    onStdOut() { }
+    onStdErr() { }
+    onStepBegin() { }
+    onStepEnd() { }
+    version() {
+        return "v2";
+    }
+    onTestBegin() { }
+    onTestEnd(test, result) {
+        // upload folder to R2
+        console.log(`Finished test ${test.title}: ${result.status}`); // comment this out before merging - we have list reporter to report on ci
+        // console.log("result.attachments", result.attachments);
+        // iterate over attachments
+        result.attachments.forEach(async (attachment) => {
+            if (!attachment.path)
+                return;
+            const folder = path_1.default.relative(this._outputFolder + "/data", attachment.path);
+            const folderName = folder.split("/")[0];
+            console.log("uploading to R2: ", folderName);
+            // on test gen run, we don't have PROJECT_NAME or GITHUB_RUN_ID so we skip uploading since we anyways handle uploads for that, this is a stopgap
+            if (!process.env.PROJECT_NAME || !"10632667227") {
+                console.log("Skipping upload of trace directory since PROJECT_NAME or GITHUB_RUN_ID is not set");
+                return;
+            }
+            await (0, upload_1.uploadDirectory)({
+                sourceDir: this._outputFolder + "/data/" + folderName,
+                destinationDir: process.env.PROJECT_NAME +
+                    "/" +
+                    "10632667227" +
+                    "/data/" +
+                    folderName,
+                uploadBucket: "test-report",
+            });
+        });
+    }
+    onConfigure(config) {
+        this.config = config;
+    }
+    onBegin(suite) {
+        console.log("Using @empiricalrun/playwright-utils custom reporter");
+        const { outputFolder, open, attachmentsBaseURL, host, port } = this._resolveOptions();
+        this._outputFolder = outputFolder;
+        this._open = open;
+        this._host = host;
+        this._port = port;
+        this._attachmentsBaseURL = attachmentsBaseURL;
+        this.suite = suite;
+    }
+    _resolveOptions() {
+        const outputFolder = reportFolderFromEnv() ??
+            (0, util_1.resolveReporterOutputPath)("playwright-report", this._options.configDir, this._options.outputFolder);
+        return {
+            outputFolder,
+            open: getHtmlReportOptionProcessEnv() || this._options.open || "on-failure",
+            attachmentsBaseURL: 
+            /* process.env.PLAYWRIGHT_HTML_ATTACHMENTS_BASE_URL || */
+            this._options.attachmentsBaseURL || "data/",
+            host: /* process.env.PLAYWRIGHT_HTML_HOST || */ this._options.host,
+            port: /* process.env.PLAYWRIGHT_HTML_PORT
+              ? +process.env.PLAYWRIGHT_HTML_PORT
+              :*/ this._options.port,
+        };
+    }
+    // override onTestBegin(test: TestCasePublic) {
+    //   console.log("onTestBegin, test: ", test.title);
+    // }
+    // override onTestEnd(test: TestCasePublic, result: TestResultPublic) {
+    //   console.log("onTestEnd, test: ", test.title, result.status);
+    //   // check path and start upload
+    //   result.attachments.forEach((attachment) => {
+    //     console.log("attachment: ", attachment);
+    //   });
+    // }
+    _isSubdirectory(parentDir, dir) {
+        const relativePath = path_1.default.relative(parentDir, dir);
+        return (!!relativePath &&
+            !relativePath.startsWith("..") &&
+            !path_1.default.isAbsolute(relativePath));
+    }
+    onError(error) {
+        this._topLevelErrors.push(error);
+    }
+    async onEnd(result) {
+        const projectSuites = this.suite.suites;
+        // Commenting out this line causes the outputs to not get deleted
+        // await removeFolders([this._outputFolder]);
+        const builder = new HtmlBuilder(this.config, this._outputFolder, this._attachmentsBaseURL);
+        this._buildResult = await builder.build(this.config.metadata, projectSuites, result, this._topLevelErrors);
+        // upload trace directory
+        if (!process.env.PROJECT_NAME || !"10632667227") {
+            console.log("Skipping upload of trace directory since PROJECT_NAME or GITHUB_RUN_ID is not set");
+            return;
+        }
+        const startTime = new Date().getTime();
+        console.log("Starting final report upload at: ", new Intl.DateTimeFormat("en-US", {
+            hour: "2-digit",
+            minute: "2-digit",
+            second: "2-digit",
+        }).format(startTime));
+        await Promise.allSettled([
+            (0, upload_1.uploadDirectory)({
+                sourceDir: this._outputFolder + "/trace",
+                destinationDir: process.env.PROJECT_NAME + "/" + "10632667227" + "/trace",
+                uploadBucket: "test-report",
+            }),
+            // upload summary.json
+            (0, upload_1.uploadDirectory)({
+                sourceDir: this._outputFolder,
+                fileList: [
+                    path_1.default.join(this._outputFolder, "summary.json"),
+                    // path.join(this._outputFolder, "data", ".last-run.json"),
+                ],
+                destinationDir: process.env.PROJECT_NAME + "/" + "10632667227",
+                uploadBucket: "test-report",
+            }),
+            // upload index.html
+            (0, upload_1.uploadDirectory)({
+                sourceDir: this._outputFolder,
+                fileList: [path_1.default.join(this._outputFolder, "index.html")],
+                destinationDir: process.env.PROJECT_NAME + "/" + "10632667227",
+                uploadBucket: "test-report",
+            }),
+        ]);
+        const endTime = new Date().getTime();
+        console.log("Finished final report upload at: ", new Intl.DateTimeFormat("en-US", {
+            hour: "2-digit",
+            minute: "2-digit",
+            second: "2-digit",
+        }).format(endTime));
+        // time difference
+        const timeDiff = endTime - startTime;
+        console.log("Time taken to upload after tests ended: ", timeDiff, "ms");
+    }
+    async onExit() {
+        if ("true" || !this._buildResult)
+            return;
+        const { ok, singleTestId } = this._buildResult;
+        const shouldOpen = !this._options._isTestServer &&
+            (this._open === "always" || (!ok && this._open === "on-failure"));
+        if (shouldOpen) {
+            await showHTMLReport(this._outputFolder, this._host, this._port, singleTestId);
+        }
+        else if (this._options._mode === "test") {
+            const packageManagerCommand = (0, utils_1.getPackageManagerExecCommand)();
+            const relativeReportPath = this._outputFolder === standaloneDefaultFolder()
+                ? ""
+                : " " + path_1.default.relative(process.cwd(), this._outputFolder);
+            const hostArg = this._host ? ` --host ${this._host}` : "";
+            const portArg = this._port ? ` --port ${this._port}` : "";
+            console.log("");
+            console.log("To open last HTML report run:");
+            console.log(base_1.colors.cyan(`
+  ${packageManagerCommand} playwright show-report${relativeReportPath}${hostArg}${portArg}
+`));
+        }
+    }
+}
+function reportFolderFromEnv() {
+    // Note: PLAYWRIGHT_HTML_REPORT is for backwards compatibility.
+    const envValue = false;
+    // process.env.PLAYWRIGHT_HTML_OUTPUT_DIR ||
+    // process.env.PLAYWRIGHT_HTML_REPORT;
+    return envValue ? path_1.default.resolve(envValue) : undefined;
+}
+function getHtmlReportOptionProcessEnv() {
+    // Note: PW_TEST_HTML_REPORT_OPEN is for backwards compatibility.
+    // const htmlOpenEnv = process.env.PLAYWRIGHT_HTML_OPEN || process.env.PW_TEST_HTML_REPORT_OPEN;
+    const htmlOpenEnv = false;
+    if (!htmlOpenEnv)
+        return undefined;
+    if (!isHtmlReportOption(htmlOpenEnv)) {
+        console.log(base_1.colors.red(`Configuration Error: HTML reporter Invalid value for PLAYWRIGHT_HTML_OPEN: ${htmlOpenEnv}. Valid values are: ${htmlReportOptions.join(", ")}`));
+        return undefined;
+    }
+    return htmlOpenEnv;
+}
+function standaloneDefaultFolder() {
+    return (reportFolderFromEnv() ??
+        // cleanup this "test-results" value since this is should not be used anyways
+        (0, util_1.resolveReporterOutputPath)("test-results", process.cwd(), undefined));
+}
+async function showHTMLReport(reportFolder, host = "localhost", port, testId) {
+    const folder = reportFolder ?? standaloneDefaultFolder();
+    try {
+        (0, utils_1.assert)(fs_1.default.statSync(folder).isDirectory());
+    }
+    catch (e) {
+        console.log(base_1.colors.red(`No report found at "${folder}"`));
+        (0, utils_1.gracefullyProcessExitDoNotHang)(1);
+        return;
+    }
+    const server = startHtmlReportServer(folder);
+    await server.start({ port, host, preferredPort: port ? undefined : 9323 });
+    let url = server.urlPrefix("human-readable");
+    console.log("");
+    console.log(base_1.colors.cyan(`  Serving HTML report at ${url}. Press Ctrl+C to quit.`));
+    if (testId)
+        url += `#?testId=${testId}`;
+    url = url.replace("0.0.0.0", "localhost");
+    await (0, utilsBundle_1.open)(url, { wait: true }).catch(() => { });
+    await new Promise(() => { });
+}
+exports.showHTMLReport = showHTMLReport;
+function startHtmlReportServer(folder) {
+    const server = new utils_1.HttpServer();
+    server.routePrefix("/", (request, response) => {
+        let relativePath = new URL("http://localhost" + request.url).pathname;
+        if (relativePath.startsWith("/trace/file")) {
+            const url = new URL("http://localhost" + request.url);
+            try {
+                return server.serveFile(request, response, url.searchParams.get("path"));
+            }
+            catch (e) {
+                return false;
+            }
+        }
+        if (relativePath.endsWith("/stall.js"))
+            return true;
+        if (relativePath === "/")
+            relativePath = "/index.html";
+        const absolutePath = path_1.default.join(folder, ...relativePath.split("/"));
+        return server.serveFile(request, response, absolutePath);
+    });
+    return server;
+}
+exports.startHtmlReportServer = startHtmlReportServer;
+class HtmlBuilder {
+    _config;
+    _reportFolder;
+    _stepsInFile = new utils_1.MultiMap();
+    _dataZipFile;
+    _hasTraces = false;
+    _attachmentsBaseURL;
+    constructor(config, outputDir, attachmentsBaseURL) {
+        this._config = config;
+        this._reportFolder = outputDir;
+        fs_1.default.mkdirSync(this._reportFolder, { recursive: true });
+        this._dataZipFile = new zipBundle_1.yazl.ZipFile();
+        this._attachmentsBaseURL = attachmentsBaseURL;
+    }
+    async build(metadata, projectSuites, result, topLevelErrors) {
+        const data = new Map();
+        for (const projectSuite of projectSuites) {
+            const testDir = projectSuite.project().testDir;
+            for (const fileSuite of projectSuite.suites) {
+                const fileName = this._relativeLocation(fileSuite.location).file;
+                // Preserve file ids computed off the testDir.
+                const relativeFile = path_1.default.relative(testDir, fileSuite.location.file);
+                const fileId = (0, utils_1.calculateSha1)((0, utils_1.toPosixPath)(relativeFile)).slice(0, 20);
+                let fileEntry = data.get(fileId);
+                if (!fileEntry) {
+                    fileEntry = {
+                        testFile: { fileId, fileName, tests: [] },
+                        testFileSummary: {
+                            fileId,
+                            fileName,
+                            tests: [],
+                            stats: emptyStats(),
+                        },
+                    };
+                    data.set(fileId, fileEntry);
+                }
+                const { testFile, testFileSummary } = fileEntry;
+                const testEntries = [];
+                this._processSuite(fileSuite, projectSuite.project().name, [], testEntries);
+                for (const test of testEntries) {
+                    testFile.tests.push(test.testCase);
+                    testFileSummary.tests.push(test.testCaseSummary);
+                }
+            }
+        }
+        createSnippets(this._stepsInFile);
+        let ok = true;
+        for (const [fileId, { testFile, testFileSummary }] of data) {
+            const stats = testFileSummary.stats;
+            for (const test of testFileSummary.tests) {
+                if (test.outcome === "expected")
+                    ++stats.expected;
+                if (test.outcome === "skipped")
+                    ++stats.skipped;
+                if (test.outcome === "unexpected")
+                    ++stats.unexpected;
+                if (test.outcome === "flaky")
+                    ++stats.flaky;
+                ++stats.total;
+            }
+            stats.ok = stats.unexpected + stats.flaky === 0;
+            if (!stats.ok)
+                ok = false;
+            const testCaseSummaryComparator = (t1, t2) => {
+                const w1 = (t1.outcome === "unexpected" ? 1000 : 0) +
+                    (t1.outcome === "flaky" ? 1 : 0);
+                const w2 = (t2.outcome === "unexpected" ? 1000 : 0) +
+                    (t2.outcome === "flaky" ? 1 : 0);
+                return w2 - w1;
+            };
+            testFileSummary.tests.sort(testCaseSummaryComparator);
+            this._addDataFile(fileId + ".json", testFile);
+        }
+        const htmlReport = {
+            metadata,
+            startTime: result.startTime.getTime(),
+            duration: result.duration,
+            files: [...data.values()].map((e) => e.testFileSummary),
+            projectNames: projectSuites.map((r) => r.project().name),
+            stats: {
+                ...[...data.values()].reduce((a, e) => addStats(a, e.testFileSummary.stats), emptyStats()),
+            },
+            errors: topLevelErrors.map((error) => (0, base_1.formatError)(error, true).message),
+        };
+        htmlReport.files.sort((f1, f2) => {
+            const w1 = f1.stats.unexpected * 1000 + f1.stats.flaky;
+            const w2 = f2.stats.unexpected * 1000 + f2.stats.flaky;
+            return w2 - w1;
+        });
+        this._addDataFile("report.json", htmlReport);
+        // Copy app.
+        const appFolder = path_1.default.join(require.resolve("playwright-core"), "..", "lib", "vite", "htmlReport");
+        await (0, utils_1.copyFileAndMakeWritable)(path_1.default.join(appFolder, "index.html"), path_1.default.join(this._reportFolder, "index.html"));
+        // Copy trace viewer.
+        if (this._hasTraces) {
+            const traceViewerFolder = path_1.default.join(require.resolve("playwright-core"), "..", "lib", "vite", "traceViewer");
+            const traceViewerTargetFolder = path_1.default.join(this._reportFolder, "trace");
+            const traceViewerAssetsTargetFolder = path_1.default.join(traceViewerTargetFolder, "assets");
+            fs_1.default.mkdirSync(traceViewerAssetsTargetFolder, { recursive: true });
+            for (const file of fs_1.default.readdirSync(traceViewerFolder)) {
+                if (file.endsWith(".map") ||
+                    file.includes("watch") ||
+                    file.includes("assets"))
+                    continue;
+                await (0, utils_1.copyFileAndMakeWritable)(path_1.default.join(traceViewerFolder, file), path_1.default.join(traceViewerTargetFolder, file));
+            }
+            for (const file of fs_1.default.readdirSync(path_1.default.join(traceViewerFolder, "assets"))) {
+                if (file.endsWith(".map") || file.includes("xtermModule"))
+                    continue;
+                await (0, utils_1.copyFileAndMakeWritable)(path_1.default.join(traceViewerFolder, "assets", file), path_1.default.join(traceViewerAssetsTargetFolder, file));
+            }
+        }
+        // Inline report data.
+        const indexFile = path_1.default.join(this._reportFolder, "index.html");
+        fs_1.default.appendFileSync(indexFile, '<script>\nwindow.playwrightReportBase64 = "data:application/zip;base64,');
+        await new Promise((f) => {
+            this._dataZipFile.end(undefined, () => {
+                this._dataZipFile.outputStream.pipe(new Base64Encoder())
+                    .pipe(fs_1.default.createWriteStream(indexFile, { flags: "a" }))
+                    .on("close", f);
+            });
+        });
+        fs_1.default.appendFileSync(indexFile, '";</script>');
+        let singleTestId;
+        if (htmlReport.stats.total === 1) {
+            const testFile = data.values().next().value?.testFile;
+            singleTestId = testFile?.tests[0]?.testId;
+        }
+        return { ok, singleTestId };
+    }
+    _addDataFile(fileName, data) {
+        this._dataZipFile.addBuffer(Buffer.from(JSON.stringify(data)), fileName);
+    }
+    _processSuite(suite, projectName, path, outTests) {
+        const newPath = [...path, suite.title];
+        suite.entries().forEach((e) => {
+            if (e.type === "test")
+                outTests.push(this._createTestEntry(e, projectName, newPath));
+            else
+                this._processSuite(e, projectName, newPath, outTests);
+        });
+    }
+    _createTestEntry(test, projectName, path) {
+        const duration = test.results.reduce((a, r) => a + r.duration, 0);
+        const location = this._relativeLocation(test.location);
+        path = path.slice(1).filter((path) => path.length > 0);
+        const results = test.results.map((r) => this._createTestResult(test, r));
+        return {
+            testCase: {
+                testId: test.id,
+                title: test.title,
+                projectName,
+                location,
+                duration,
+                // Annotations can be pushed directly, with a wrong type.
+                annotations: test.annotations.map((a) => ({
+                    type: a.type,
+                    description: a.description ? String(a.description) : a.description,
+                })),
+                tags: test.tags,
+                outcome: test.outcome(),
+                path,
+                results,
+                ok: test.outcome() === "expected" || test.outcome() === "flaky",
+            },
+            testCaseSummary: {
+                testId: test.id,
+                title: test.title,
+                projectName,
+                location,
+                duration,
+                // Annotations can be pushed directly, with a wrong type.
+                annotations: test.annotations.map((a) => ({
+                    type: a.type,
+                    description: a.description ? String(a.description) : a.description,
+                })),
+                tags: test.tags,
+                outcome: test.outcome(),
+                path,
+                ok: test.outcome() === "expected" || test.outcome() === "flaky",
+                results: results.map((result) => {
+                    return {
+                        attachments: result.attachments.map((a) => ({
+                            name: a.name,
+                            contentType: a.contentType,
+                            path: a.path,
+                        })),
+                    };
+                }),
+            },
+        };
+    }
+    _serializeAttachments(attachments) {
+        let lastAttachment;
+        return attachments
+            .map((a) => {
+            if (a.name === "trace")
+                this._hasTraces = true;
+            if ((a.name === "stdout" || a.name === "stderr") &&
+                a.contentType === "text/plain") {
+                if (lastAttachment &&
+                    lastAttachment.name === a.name &&
+                    lastAttachment.contentType === a.contentType) {
+                    lastAttachment.body += (0, base_1.stripAnsiEscapes)(a.body);
+                    return null;
+                }
+                a.body = (0, base_1.stripAnsiEscapes)(a.body);
+                lastAttachment = a;
+                return a;
+            }
+            if (a.path) {
+                // in our custom reporter, we do not delete the original files onEnd
+                const relativePath = path_1.default.relative(this._reportFolder, a.path);
+                // removed logic which renamed original files to different versions with SHAs
+                return {
+                    name: a.name,
+                    contentType: a.contentType,
+                    path: relativePath,
+                    body: a.body,
+                };
+            }
+            if (a.body instanceof Buffer) {
+                if (isTextContentType(a.contentType)) {
+                    // Content type is like this: "text/html; charset=UTF-8"
+                    const charset = a.contentType.match(/charset=(.*)/)?.[1];
+                    try {
+                        const body = a.body.toString(charset || "utf-8");
+                        return {
+                            name: a.name,
+                            contentType: a.contentType,
+                            body,
+                        };
+                    }
+                    catch (e) {
+                        // Invalid encoding, fall through and save to file.
+                    }
+                }
+                fs_1.default.mkdirSync(path_1.default.join(this._reportFolder, "data"), {
+                    recursive: true,
+                });
+                const extension = (0, utils_1.sanitizeForFilePath)(path_1.default.extname(a.name).replace(/^\./, "")) ||
+                    utilsBundle_1.mime.getExtension(a.contentType) ||
+                    "dat";
+                const sha1 = (0, utils_1.calculateSha1)(a.body) + "." + extension;
+                fs_1.default.writeFileSync(path_1.default.join(this._reportFolder, "data", sha1), a.body);
+                return {
+                    name: a.name,
+                    contentType: a.contentType,
+                    path: this._attachmentsBaseURL + sha1,
+                };
+            }
+            // string
+            return {
+                name: a.name,
+                contentType: a.contentType,
+                body: a.body,
+            };
+        })
+            .filter(Boolean);
+    }
+    _createTestResult(test, result) {
+        return {
+            duration: result.duration,
+            startTime: result.startTime.toISOString(),
+            retry: result.retry,
+            steps: dedupeSteps(result.steps).map((s) => this._createTestStep(s)),
+            errors: (0, base_1.formatResultFailure)(test, result, "", true).map((error) => error.message),
+            status: result.status,
+            attachments: this._serializeAttachments([
+                ...result.attachments,
+                ...result.stdout.map((m) => stdioAttachment(m, "stdout")),
+                ...result.stderr.map((m) => stdioAttachment(m, "stderr")),
+            ]),
+        };
+    }
+    _createTestStep(dedupedStep) {
+        const { step, duration, count } = dedupedStep;
+        const result = {
+            title: step.title,
+            startTime: step.startTime.toISOString(),
+            duration,
+            steps: dedupeSteps(step.steps).map((s) => this._createTestStep(s)),
+            location: this._relativeLocation(step.location),
+            error: step.error?.message,
+            count,
+        };
+        if (result.location)
+            this._stepsInFile.set(result.location.file, result);
+        return result;
+    }
+    _relativeLocation(location) {
+        if (!location)
+            return undefined;
+        const file = (0, utils_1.toPosixPath)(path_1.default.relative(this._config.rootDir, location.file));
+        return {
+            file,
+            line: location.line,
+            column: location.column,
+        };
+    }
+}
+const emptyStats = () => {
+    return {
+        total: 0,
+        expected: 0,
+        unexpected: 0,
+        flaky: 0,
+        skipped: 0,
+        ok: true,
+    };
+};
+const addStats = (stats, delta) => {
+    stats.total += delta.total;
+    stats.skipped += delta.skipped;
+    stats.expected += delta.expected;
+    stats.unexpected += delta.unexpected;
+    stats.flaky += delta.flaky;
+    stats.ok = stats.ok && delta.ok;
+    return stats;
+};
+class Base64Encoder extends stream_1.Transform {
+    _remainder;
+    _transform(chunk, encoding, callback) {
+        if (this._remainder) {
+            chunk = Buffer.concat([this._remainder, chunk]);
+            this._remainder = undefined;
+        }
+        const remaining = chunk.length % 3;
+        if (remaining) {
+            this._remainder = chunk.slice(chunk.length - remaining);
+            chunk = chunk.slice(0, chunk.length - remaining);
+        }
+        chunk = chunk.toString("base64");
+        this.push(Buffer.from(chunk));
+        callback();
+    }
+    _flush(callback) {
+        if (this._remainder)
+            this.push(Buffer.from(this._remainder.toString("base64")));
+        callback();
+    }
+}
+function isTextContentType(contentType) {
+    return (contentType.startsWith("text/") ||
+        contentType.startsWith("application/json"));
+}
+function stdioAttachment(chunk, type) {
+    if (typeof chunk === "string") {
+        return {
+            name: type,
+            contentType: "text/plain",
+            body: chunk,
+        };
+    }
+    return {
+        name: type,
+        contentType: "application/octet-stream",
+        body: chunk,
+    };
+}
+function dedupeSteps(steps) {
+    const result = [];
+    let lastResult = undefined;
+    for (const step of steps) {
+        const canDedupe = !step.error &&
+            step.duration >= 0 &&
+            step.location?.file &&
+            !step.steps.length;
+        const lastStep = lastResult?.step;
+        if (canDedupe &&
+            lastResult &&
+            lastStep &&
+            step.category === lastStep.category &&
+            step.title === lastStep.title &&
+            step.location?.file === lastStep.location?.file &&
+            step.location?.line === lastStep.location?.line &&
+            step.location?.column === lastStep.location?.column) {
+            ++lastResult.count;
+            lastResult.duration += step.duration;
+            continue;
+        }
+        lastResult = { step, count: 1, duration: step.duration };
+        result.push(lastResult);
+        if (!canDedupe)
+            lastResult = undefined;
+    }
+    return result;
+}
+function createSnippets(stepsInFile) {
+    for (const file of stepsInFile.keys()) {
+        let source;
+        try {
+            source = fs_1.default.readFileSync(file, "utf-8") + "\n//";
+        }
+        catch (e) {
+            continue;
+        }
+        const lines = source.split("\n").length;
+        const highlighted = (0, code_frame_1.codeFrameColumns)(source, { start: { line: lines, column: 1 } }, { highlightCode: true, linesAbove: lines, linesBelow: 0 });
+        const highlightedLines = highlighted.split("\n");
+        const lineWithArrow = highlightedLines[highlightedLines.length - 1];
+        for (const step of stepsInFile.get(file)) {
+            // Don't bother with snippets that have less than 3 lines.
+            if (step.location.line < 2 || step.location.line >= lines)
+                continue;
+            // Cut out snippet.
+            const snippetLines = highlightedLines.slice(step.location.line - 2, step.location.line + 1);
+            // Relocate arrow.
+            const index = lineWithArrow?.indexOf("^");
+            const shiftedArrow = lineWithArrow?.slice(0, index) +
+                " ".repeat(step.location.column - 1) +
+                lineWithArrow?.slice(index);
+            // Insert arrow line.
+            snippetLines.splice(2, 0, shiftedArrow);
+            step.snippet = snippetLines.join("\n");
+        }
+    }
+}
+exports.default = HtmlReporter;