ortoni-report 4.0.2 → 4.0.4

package/dist/helpers/fileManager.js

@@ -0,0 +1,60 @@
+import fs from "fs";
+import path from "path";
+import { readBundledTemplate } from "./templateLoader";
+export class FileManager {
+    constructor(folderPath) {
+        this.folderPath = folderPath;
+    }
+    ensureReportDirectory() {
+        const ortoniDataFolder = path.join(this.folderPath, "ortoni-data");
+        if (!fs.existsSync(this.folderPath)) {
+            fs.mkdirSync(this.folderPath, { recursive: true });
+        }
+        else {
+            if (fs.existsSync(ortoniDataFolder)) {
+                fs.rmSync(ortoniDataFolder, { recursive: true, force: true });
+            }
+        }
+    }
+    async writeReportFile(filename, data) {
+        let html = await readBundledTemplate();
+        // let html = fs.readFileSync(templatePath, "utf-8");
+        const reportJSON = JSON.stringify({
+            data,
+        });
+        html = html.replace("__ORTONI_TEST_REPORTDATA__", reportJSON);
+        const outputPath = path.join(process.cwd(), this.folderPath, filename);
+        fs.writeFileSync(outputPath, html);
+        return outputPath;
+    }
+    writeRawFile(filename, data) {
+        const outputPath = path.join(process.cwd(), this.folderPath, filename);
+        fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+        const content = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+        fs.writeFileSync(outputPath, content, "utf-8");
+        return outputPath;
+    }
+    copyTraceViewerAssets(skip) {
+        if (skip)
+            return;
+        const traceViewerFolder = path.join(require.resolve("playwright-core"), "..", "lib", "vite", "traceViewer");
+        const traceViewerTargetFolder = path.join(this.folderPath, "trace");
+        const traceViewerAssetsTargetFolder = path.join(traceViewerTargetFolder, "assets");
+        fs.mkdirSync(traceViewerAssetsTargetFolder, { recursive: true });
+        // Copy main trace viewer files
+        for (const file of fs.readdirSync(traceViewerFolder)) {
+            if (file.endsWith(".map") ||
+                file.includes("watch") ||
+                file.includes("assets"))
+                continue;
+            fs.copyFileSync(path.join(traceViewerFolder, file), path.join(traceViewerTargetFolder, file));
+        }
+        // Copy assets
+        const assetsFolder = path.join(traceViewerFolder, "assets");
+        for (const file of fs.readdirSync(assetsFolder)) {
+            if (file.endsWith(".map") || file.includes("xtermModule"))
+                continue;
+            fs.copyFileSync(path.join(assetsFolder, file), path.join(traceViewerAssetsTargetFolder, file));
+        }
+    }
+}

package/dist/helpers/markdownConverter.d.ts

@@ -0,0 +1 @@
+export declare function convertMarkdownToHtml(markdownPath: string, htmlOutputPath: string): void;

package/dist/helpers/markdownConverter.js

@@ -0,0 +1,14 @@
+import fs from "fs";
+import { marked } from "marked";
+export function convertMarkdownToHtml(markdownPath, htmlOutputPath) {
+    const hasMarkdown = fs.existsSync(markdownPath);
+    const markdownContent = hasMarkdown
+        ? fs.readFileSync(markdownPath, "utf-8")
+        : "";
+    const markdownHtml = hasMarkdown ? marked(markdownContent) : "";
+    const drawerHtml = `${markdownHtml || ""}`;
+    fs.writeFileSync(htmlOutputPath, drawerHtml.trim(), "utf-8");
+    if (hasMarkdown) {
+        fs.unlinkSync(markdownPath);
+    }
+}

package/dist/helpers/resultProcessor.d.ts

@@ -0,0 +1,10 @@
+import { TestCase, TestResult } from "@playwright/test/reporter";
+import { TestResultData } from "../types/testResults";
+import { OrtoniReportConfig } from "../types/reporterConfig";
+export declare class TestResultProcessor {
+    private ansiToHtml;
+    private projectRoot;
+    constructor(projectRoot: string);
+    processTestResult(test: TestCase, result: TestResult, projectSet: Set<string>, ortoniConfig: OrtoniReportConfig): TestResultData;
+    private processSteps;
+}

package/dist/helpers/resultProcessor.js

@@ -0,0 +1,60 @@
+import AnsiToHtml from "ansi-to-html";
+import path from "path";
+import { attachFiles } from "../utils/attachFiles";
+import { normalizeFilePath, escapeHtml, extractSuites } from "../utils/utils";
+export class TestResultProcessor {
+    constructor(projectRoot) {
+        this.ansiToHtml = new AnsiToHtml({ fg: "var(--snippet-color)" });
+        this.projectRoot = projectRoot;
+    }
+    processTestResult(test, result, projectSet, ortoniConfig) {
+        const status = test.outcome() === "flaky" ? "flaky" : result.status;
+        const projectName = test.titlePath()[1];
+        projectSet.add(projectName);
+        const location = test.location;
+        const filePath = normalizeFilePath(test.titlePath()[2]);
+        const tagPattern = /@[\w]+/g;
+        const title = test.title.replace(tagPattern, "").trim();
+        const suite = test.titlePath()[3].replace(tagPattern, "").trim();
+        const suiteAndTitle = extractSuites(test.titlePath());
+        const suiteHierarchy = suiteAndTitle.hierarchy;
+        const testResult = {
+            suiteHierarchy,
+            key: test.id,
+            annotations: test.annotations,
+            testTags: test.tags,
+            location: `${filePath}:${location.line}:${location.column}`,
+            retryAttemptCount: result.retry,
+            projectName: projectName,
+            suite,
+            title,
+            status,
+            flaky: test.outcome(),
+            duration: result.duration,
+            errors: result.errors.map((e) => this.ansiToHtml.toHtml(escapeHtml(e.stack || e.toString()))),
+            steps: this.processSteps(result.steps),
+            logs: this.ansiToHtml.toHtml(escapeHtml(result.stdout
+                .concat(result.stderr)
+                .map((log) => log)
+                .join("\n"))),
+            filePath: filePath,
+            filters: projectSet,
+            base64Image: ortoniConfig.base64Image,
+            testId: `${filePath}:${projectName}:${title}`,
+        };
+        attachFiles(path.join(test.id, `retry-${result.retry}`), result, testResult, ortoniConfig, testResult.steps, testResult.errors);
+        return testResult;
+    }
+    processSteps(steps) {
+        return steps.map((step) => {
+            const stepLocation = step.location
+                ? `${path.relative(this.projectRoot, step.location.file)}:${step.location.line}:${step.location.column}`
+                : "";
+            return {
+                snippet: this.ansiToHtml.toHtml(escapeHtml(step.error?.snippet || "")),
+                title: step.title,
+                location: step.error ? stepLocation : "",
+            };
+        });
+    }
+}

package/dist/helpers/serverManager.d.ts

@@ -0,0 +1,6 @@
+import { OrtoniReportConfig } from "../types/reporterConfig";
+export declare class ServerManager {
+    private ortoniConfig;
+    constructor(ortoniConfig: OrtoniReportConfig);
+    startServer(folderPath: string, outputFilename: string, overAllStatus: string | undefined): Promise<void>;
+}

package/dist/helpers/serverManager.js

@@ -0,0 +1,15 @@
+import { startReportServer } from "../utils/expressServer";
+export class ServerManager {
+    constructor(ortoniConfig) {
+        this.ortoniConfig = ortoniConfig;
+    }
+    async startServer(folderPath, outputFilename, overAllStatus) {
+        const openOption = this.ortoniConfig.open || "never";
+        const hasFailures = overAllStatus === "failed";
+        if (openOption === "always" ||
+            (openOption === "on-failure" && hasFailures)) {
+            startReportServer(folderPath, outputFilename, this.ortoniConfig.port, openOption);
+            await new Promise((_resolve) => { });
+        }
+    }
+}

package/dist/helpers/templateLoader.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Read the bundled index.html template.
+ *
+ * Resolution order:
+ *  1) require.resolve('<pkgName>/dist/index.html') via require (synchronous; CJS fast path)
+ *  2) createRequire(resolve) via dynamic import('module') (async ESM fallback)
+ *  3) relative to this file: ../dist/index.html (dev/run-from-repo)
+ *  4) node_modules/<pkgName>/dist/index.html from process.cwd()
+ *  5) process.cwd()/dist/index.html
+ *
+ * Returns the template string. Throws a helpful Error if not found.
+ *
+ * NOTE: This function is async because dynamic import('module') is async in ESM.
+ */
+export declare function readBundledTemplate(pkgName?: string): Promise<string>;

package/dist/helpers/templateLoader.js

@@ -0,0 +1,88 @@
+// src/helpers/templateLoader.ts
+import fs from "fs";
+import path from "path";
+/**
+ * Read the bundled index.html template.
+ *
+ * Resolution order:
+ *  1) require.resolve('<pkgName>/dist/index.html') via require (synchronous; CJS fast path)
+ *  2) createRequire(resolve) via dynamic import('module') (async ESM fallback)
+ *  3) relative to this file: ../dist/index.html (dev/run-from-repo)
+ *  4) node_modules/<pkgName>/dist/index.html from process.cwd()
+ *  5) process.cwd()/dist/index.html
+ *
+ * Returns the template string. Throws a helpful Error if not found.
+ *
+ * NOTE: This function is async because dynamic import('module') is async in ESM.
+ */
+export async function readBundledTemplate(pkgName = "ortoni-report") {
+    const packagedRel = "dist/index.html";
+    // 1) Sync CJS fast-path: if `require` exists (typical for CJS consumers)
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        if (typeof require === "function") {
+            // Use require.resolve to reliably find the file inside installed package
+            const resolved = require.resolve(`${pkgName}/${packagedRel}`);
+            if (fs.existsSync(resolved)) {
+                return fs.readFileSync(resolved, "utf-8");
+            }
+        }
+    }
+    catch {
+        // ignore and continue to async fallback
+    }
+    // 2) Async ESM-safe createRequire via dynamic import (no eval)
+    try {
+        // dynamic import of 'module' works in ESM environments
+        const moduleNS = await import("module");
+        if (moduleNS && typeof moduleNS.createRequire === "function") {
+            const createRequire = moduleNS.createRequire;
+            // createRequire needs a filename/URL; use this file (works for both ESM and CJS)
+            const req = createRequire(
+            // @ts-ignore
+            typeof __filename !== "undefined" ? __filename : import.meta.url);
+            const resolved = req.resolve(`${pkgName}/${packagedRel}`);
+            if (fs.existsSync(resolved)) {
+                return fs.readFileSync(resolved, "utf-8");
+            }
+        }
+    }
+    catch {
+        // ignore and try file fallbacks below
+    }
+    // 3) Relative to this module (useful in dev or mono-repo)
+    try {
+        const here = path.resolve(__dirname, "../dist/index.html");
+        if (fs.existsSync(here))
+            return fs.readFileSync(here, "utf-8");
+    }
+    catch {
+        // ignore
+    }
+    // 4) node_modules lookup from process.cwd()
+    try {
+        const nm = path.join(process.cwd(), "node_modules", pkgName, packagedRel);
+        if (fs.existsSync(nm))
+            return fs.readFileSync(nm, "utf-8");
+    }
+    catch {
+        // ignore
+    }
+    // 5) fallback to process.cwd()/dist/index.html
+    try {
+        const alt = path.join(process.cwd(), "dist", "index.html");
+        if (fs.existsSync(alt))
+            return fs.readFileSync(alt, "utf-8");
+    }
+    catch {
+        // ignore
+    }
+    // Helpful error for maintainers / users
+    throw new Error(`ortoni-report template not found (tried:\n` +
+        `  - require.resolve('${pkgName}/${packagedRel}')\n` +
+        `  - import('module').createRequire(...).resolve('${pkgName}/${packagedRel}')\n` +
+        `  - relative ../dist/index.html\n` +
+        `  - ${path.join(process.cwd(), "node_modules", pkgName, packagedRel)}\n` +
+        `  - ${path.join(process.cwd(), "dist", "index.html")}\n` +
+        `Ensure 'dist/index.html' is present in the published package and package.json 'files' includes 'dist/'.`);
+}