ortoni-report 4.0.2-beta.0 → 4.1.0-test.0

package/dist/{chunk-INS3E7E6.mjs → chunk-4RZ5C7KY.mjs}

@@ -8,241 +8,14 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-// src/helpers/fileManager.ts
-import fs from "fs";
-import path from "path";
-var FileManager = class {
-  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 });
-      }
-    }
-  }
-  writeReportFile(filename, data) {
-    const templatePath = path.join(__dirname, "..", "index.html");
-    console.log(templatePath);
-    let html = fs.readFileSync(templatePath, "utf-8");
-    const reportJSON = JSON.stringify({
-      data
-    });
-    html = html.replace("__ORTONI_TEST_REPORTDATA__", reportJSON);
-    console.log(`Writing report to ${reportJSON}`);
-    const outputDir = path.join(process.cwd(), this.folderPath);
-    if (!fs.existsSync(outputDir)) {
-      fs.mkdirSync(outputDir, { recursive: true });
-    }
-    const outputPath = path.join(outputDir, 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 });
-    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)
-      );
-    }
-    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)
-      );
-    }
-  }
-};
-
-// src/utils/groupProjects.ts
-function groupResults(config, results) {
-  if (config.showProject) {
-    const groupedResults = results.reduce((acc, result, index) => {
-      const testId = `${result.filePath}:${result.projectName}:${result.title}`;
-      const key = `${testId}-${result.key}-${result.retryAttemptCount}`;
-      const { filePath, suite, projectName } = result;
-      acc[filePath] = acc[filePath] || {};
-      acc[filePath][suite] = acc[filePath][suite] || {};
-      acc[filePath][suite][projectName] = acc[filePath][suite][projectName] || [];
-      acc[filePath][suite][projectName].push({ ...result, index, testId, key });
-      return acc;
-    }, {});
-    return groupedResults;
-  } else {
-    const groupedResults = results.reduce((acc, result, index) => {
-      const testId = `${result.filePath}:${result.projectName}:${result.title}`;
-      const key = `${testId}-${result.key}-${result.retryAttemptCount}`;
-      const { filePath, suite } = result;
-      acc[filePath] = acc[filePath] || {};
-      acc[filePath][suite] = acc[filePath][suite] || [];
-      acc[filePath][suite].push({ ...result, index, testId, key });
-      return acc;
-    }, {});
-    return groupedResults;
-  }
-}
-
-// src/helpers/HTMLGenerator.ts
-var HTMLGenerator = class {
-  constructor(ortoniConfig, dbManager) {
-    this.ortoniConfig = ortoniConfig;
-    this.dbManager = dbManager;
-  }
-  async generateFinalReport(filteredResults, totalDuration, results, projectSet) {
-    const data = await this.prepareReportData(
-      filteredResults,
-      totalDuration,
-      results,
-      projectSet
-    );
-    return data;
-  }
-  async getReportData() {
-    return {
-      summary: await this.dbManager.getSummaryData(),
-      trends: await this.dbManager.getTrends(),
-      flakyTests: await this.dbManager.getFlakyTests(),
-      slowTests: await this.dbManager.getSlowTests()
-    };
-  }
-  async prepareReportData(filteredResults, totalDuration, results, projectSet) {
-    const totalTests = filteredResults.length;
-    const passedTests = results.filter((r) => r.status === "passed").length;
-    const flakyTests = results.filter((r) => r.status === "flaky").length;
-    const failed = filteredResults.filter(
-      (r) => r.status === "failed" || r.status === "timedOut"
-    ).length;
-    const successRate = ((passedTests + flakyTests) / totalTests * 100).toFixed(2);
-    const allTags = /* @__PURE__ */ new Set();
-    results.forEach(
-      (result) => result.testTags.forEach((tag) => allTags.add(tag))
-    );
-    const projectResults = this.calculateProjectResults(
-      filteredResults,
-      results,
-      projectSet
-    );
-    const lastRunDate = (/* @__PURE__ */ new Date()).toLocaleString();
-    const testHistories = await Promise.all(
-      results.map(async (result) => {
-        const testId = `${result.filePath}:${result.projectName}:${result.title}`;
-        const history = await this.dbManager.getTestHistory(testId);
-        return {
-          testId,
-          history
-        };
-      })
-    );
-    return {
-      summary: {
-        overAllResult: {
-          pass: passedTests,
-          fail: failed,
-          skip: results.filter((r) => r.status === "skipped").length,
-          retry: results.filter((r) => r.retryAttemptCount).length,
-          flaky: flakyTests,
-          total: filteredResults.length
-        },
-        successRate,
-        lastRunDate,
-        totalDuration,
-        stats: this.extractProjectStats(projectResults)
-      },
-      testResult: {
-        tests: groupResults(this.ortoniConfig, results),
-        testHistories,
-        allTags: Array.from(allTags),
-        set: projectSet
-      },
-      userConfig: {
-        projectName: this.ortoniConfig.projectName,
-        authorName: this.ortoniConfig.authorName,
-        type: this.ortoniConfig.testType,
-        title: this.ortoniConfig.title
-      },
-      userMeta: {
-        meta: this.ortoniConfig.meta
-      },
-      preferences: {
-        logo: this.ortoniConfig.logo || void 0,
-        showProject: this.ortoniConfig.showProject || false
-      },
-      analytics: {
-        reportData: await this.getReportData()
-      }
-    };
-  }
-  calculateProjectResults(filteredResults, results, projectSet) {
-    return Array.from(projectSet).map((projectName) => {
-      const projectTests = filteredResults.filter(
-        (r) => r.projectName === projectName
-      );
-      const allProjectTests = results.filter(
-        (r) => r.projectName === projectName
-      );
-      return {
-        projectName,
-        passedTests: projectTests.filter((r) => r.status === "passed").length,
-        failedTests: projectTests.filter(
-          (r) => r.status === "failed" || r.status === "timedOut"
-        ).length,
-        skippedTests: allProjectTests.filter((r) => r.status === "skipped").length,
-        retryTests: allProjectTests.filter((r) => r.retryAttemptCount).length,
-        flakyTests: allProjectTests.filter((r) => r.status === "flaky").length,
-        totalTests: projectTests.length
-      };
-    });
-  }
-  extractProjectStats(projectResults) {
-    return {
-      projectNames: projectResults.map((result) => result.projectName),
-      totalTests: projectResults.map((result) => result.totalTests),
-      passedTests: projectResults.map((result) => result.passedTests),
-      failedTests: projectResults.map((result) => result.failedTests),
-      skippedTests: projectResults.map((result) => result.skippedTests),
-      retryTests: projectResults.map((result) => result.retryTests),
-      flakyTests: projectResults.map((result) => result.flakyTests)
-    };
-  }
-};
-
 // src/utils/utils.ts
-import path2 from "path";
+import path from "path";
 function normalizeFilePath(filePath) {
-  const normalizedPath = path2.normalize(filePath);
-  return path2.basename(normalizedPath);
+  const normalizedPath = path.normalize(filePath);
+  return path.basename(normalizedPath);
 }
 function ensureHtmlExtension(filename) {
-  const ext = path2.extname(filename);
+  const ext = path.extname(filename);
   if (ext && ext.toLowerCase() === ".html") {
     return filename;
   }
@@ -290,67 +63,6 @@ function extractSuites(titlePath) {
   };
 }
 
-// src/utils/expressServer.ts
-import express from "express";
-import path3 from "path";
-import { spawn } from "child_process";
-function startReportServer(reportFolder, reportFilename, port = 2004, open2) {
-  const app = express();
-  app.use(express.static(reportFolder));
-  app.get("/", (_req, res) => {
-    try {
-      res.sendFile(path3.resolve(reportFolder, reportFilename));
-    } catch (error) {
-      console.error("Ortoni-Report: Error sending report file:", error);
-      res.status(500).send("Error loading report");
-    }
-  });
-  try {
-    const server = app.listen(port, () => {
-      console.log(
-        `Server is running at http://localhost:${port} 
-Press Ctrl+C to stop.`
-      );
-      if (open2 === "always" || open2 === "on-failure") {
-        try {
-          openBrowser(`http://localhost:${port}`);
-        } catch (error) {
-          console.error("Ortoni-Report: Error opening browser:", error);
-        }
-      }
-    });
-    server.on("error", (error) => {
-      if (error.code === "EADDRINUSE") {
-        console.error(
-          `Ortoni-Report: Port ${port} is already in use. Trying a different port...`
-        );
-      } else {
-        console.error("Ortoni-Report: Server error:", error);
-      }
-    });
-  } catch (error) {
-    console.error("Ortoni-Report: Error starting the server:", error);
-  }
-}
-function openBrowser(url) {
-  const platform = process.platform;
-  let command;
-  try {
-    if (platform === "win32") {
-      command = "cmd";
-      spawn(command, ["/c", "start", url]);
-    } else if (platform === "darwin") {
-      command = "open";
-      spawn(command, [url]);
-    } else {
-      command = "xdg-open";
-      spawn(command, [url]);
-    }
-  } catch (error) {
-    console.error("Ortoni-Report: Error opening the browser:", error);
-  }
-}
-
 // src/helpers/databaseManager.ts
 import { open } from "sqlite";
 import sqlite3 from "sqlite3";
@@ -625,14 +337,408 @@ var DatabaseManager = class {
   }
 };
 
+// src/utils/groupProjects.ts
+function groupResults(config, results) {
+  if (config.showProject) {
+    const groupedResults = results.reduce((acc, result, index) => {
+      const testId = `${result.filePath}:${result.projectName}:${result.title}`;
+      const key = `${testId}-${result.key}-${result.retryAttemptCount}`;
+      const { filePath, suite, projectName } = result;
+      acc[filePath] = acc[filePath] || {};
+      acc[filePath][suite] = acc[filePath][suite] || {};
+      acc[filePath][suite][projectName] = acc[filePath][suite][projectName] || [];
+      acc[filePath][suite][projectName].push({ ...result, index, testId, key });
+      return acc;
+    }, {});
+    return groupedResults;
+  } else {
+    const groupedResults = results.reduce((acc, result, index) => {
+      const testId = `${result.filePath}:${result.projectName}:${result.title}`;
+      const key = `${testId}-${result.key}-${result.retryAttemptCount}`;
+      const { filePath, suite } = result;
+      acc[filePath] = acc[filePath] || {};
+      acc[filePath][suite] = acc[filePath][suite] || [];
+      acc[filePath][suite].push({ ...result, index, testId, key });
+      return acc;
+    }, {});
+    return groupedResults;
+  }
+}
+
+// src/helpers/HTMLGenerator.ts
+var HTMLGenerator = class {
+  constructor(ortoniConfig, dbManager) {
+    this.ortoniConfig = ortoniConfig;
+    this.dbManager = dbManager;
+  }
+  async generateFinalReport(filteredResults, totalDuration, results, projectSet) {
+    const data = await this.prepareReportData(
+      filteredResults,
+      totalDuration,
+      results,
+      projectSet
+    );
+    return data;
+  }
+  /**
+   * Return safe analytics/report data.
+   * If no dbManager is provided, return empty defaults and a note explaining why.
+   */
+  async getReportData() {
+    if (!this.dbManager) {
+      return {
+        summary: {},
+        trends: {},
+        flakyTests: [],
+        slowTests: [],
+        note: "Test history/trends are unavailable (saveHistory disabled or DB not initialized)."
+      };
+    }
+    try {
+      const [summary, trends, flakyTests, slowTests] = await Promise.all([
+        this.dbManager.getSummaryData ? this.dbManager.getSummaryData() : Promise.resolve({}),
+        this.dbManager.getTrends ? this.dbManager.getTrends() : Promise.resolve({}),
+        this.dbManager.getFlakyTests ? this.dbManager.getFlakyTests() : Promise.resolve([]),
+        this.dbManager.getSlowTests ? this.dbManager.getSlowTests() : Promise.resolve([])
+      ]);
+      return {
+        summary: summary ?? {},
+        trends: trends ?? {},
+        flakyTests: flakyTests ?? [],
+        slowTests: slowTests ?? []
+      };
+    } catch (err) {
+      console.warn(
+        "HTMLGenerator: failed to read analytics from DB, continuing without history.",
+        err
+      );
+      return {
+        summary: {},
+        trends: {},
+        flakyTests: [],
+        slowTests: [],
+        note: "Test history/trends could not be loaded due to a DB error."
+      };
+    }
+  }
+  async prepareReportData(filteredResults, totalDuration, results, projectSet) {
+    const totalTests = filteredResults.length;
+    const passedTests = results.filter((r) => r.status === "passed").length;
+    const flakyTests = results.filter((r) => r.status === "flaky").length;
+    const failed = filteredResults.filter(
+      (r) => r.status === "failed" || r.status === "timedOut"
+    ).length;
+    const successRate = totalTests === 0 ? "0.00" : ((passedTests + flakyTests) / totalTests * 100).toFixed(2);
+    const allTags = /* @__PURE__ */ new Set();
+    results.forEach(
+      (result) => (result.testTags || []).forEach((tag) => allTags.add(tag))
+    );
+    const projectResults = this.calculateProjectResults(
+      filteredResults,
+      results,
+      projectSet
+    );
+    const lastRunDate = (/* @__PURE__ */ new Date()).toLocaleString();
+    const testHistories = await Promise.all(
+      results.map(async (result) => {
+        const testId = `${result.filePath}:${result.projectName}:${result.title}`;
+        if (!this.dbManager || !this.dbManager.getTestHistory) {
+          return {
+            testId,
+            history: []
+          };
+        }
+        try {
+          const history = await this.dbManager.getTestHistory(testId);
+          return {
+            testId,
+            history: history ?? []
+          };
+        } catch (err) {
+          console.warn(
+            `HTMLGenerator: failed to read history for ${testId}`,
+            err
+          );
+          return {
+            testId,
+            history: []
+          };
+        }
+      })
+    );
+    const reportData = await this.getReportData();
+    return {
+      summary: {
+        overAllResult: {
+          pass: passedTests,
+          fail: failed,
+          skip: results.filter((r) => r.status === "skipped").length,
+          retry: results.filter((r) => r.retryAttemptCount).length,
+          flaky: flakyTests,
+          total: filteredResults.length
+        },
+        successRate,
+        lastRunDate,
+        totalDuration,
+        stats: this.extractProjectStats(projectResults)
+      },
+      testResult: {
+        tests: groupResults(this.ortoniConfig, results),
+        testHistories,
+        allTags: Array.from(allTags),
+        set: projectSet
+      },
+      userConfig: {
+        projectName: this.ortoniConfig.projectName,
+        authorName: this.ortoniConfig.authorName,
+        type: this.ortoniConfig.testType,
+        title: this.ortoniConfig.title
+      },
+      userMeta: {
+        meta: this.ortoniConfig.meta
+      },
+      preferences: {
+        logo: this.ortoniConfig.logo || void 0,
+        showProject: this.ortoniConfig.showProject || false
+      },
+      analytics: {
+        reportData
+      }
+    };
+  }
+  calculateProjectResults(filteredResults, results, projectSet) {
+    return Array.from(projectSet).map((projectName) => {
+      const projectTests = filteredResults.filter(
+        (r) => r.projectName === projectName
+      );
+      const allProjectTests = results.filter(
+        (r) => r.projectName === projectName
+      );
+      return {
+        projectName,
+        passedTests: projectTests.filter((r) => r.status === "passed").length,
+        failedTests: projectTests.filter(
+          (r) => r.status === "failed" || r.status === "timedOut"
+        ).length,
+        skippedTests: allProjectTests.filter((r) => r.status === "skipped").length,
+        retryTests: allProjectTests.filter((r) => r.retryAttemptCount).length,
+        flakyTests: allProjectTests.filter((r) => r.status === "flaky").length,
+        totalTests: projectTests.length
+      };
+    });
+  }
+  extractProjectStats(projectResults) {
+    return {
+      projectNames: projectResults.map((result) => result.projectName),
+      totalTests: projectResults.map((result) => result.totalTests),
+      passedTests: projectResults.map((result) => result.passedTests),
+      failedTests: projectResults.map((result) => result.failedTests),
+      skippedTests: projectResults.map((result) => result.skippedTests),
+      retryTests: projectResults.map((result) => result.retryTests),
+      flakyTests: projectResults.map((result) => result.flakyTests)
+    };
+  }
+};
+
+// src/helpers/fileManager.ts
+import fs2 from "fs";
+import path3 from "path";
+
+// src/helpers/templateLoader.ts
+import fs from "fs";
+import path2 from "path";
+async function readBundledTemplate(pkgName = "ortoni-report") {
+  const packagedRel = "dist/index.html";
+  try {
+    if (typeof __require === "function") {
+      const resolved = __require.resolve(`${pkgName}/${packagedRel}`);
+      if (fs.existsSync(resolved)) {
+        return fs.readFileSync(resolved, "utf-8");
+      }
+    }
+  } catch {
+  }
+  try {
+    const moduleNS = await import("module");
+    if (moduleNS && typeof moduleNS.createRequire === "function") {
+      const createRequire = moduleNS.createRequire;
+      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 {
+  }
+  try {
+    const here = path2.resolve(__dirname, "../dist/index.html");
+    if (fs.existsSync(here)) return fs.readFileSync(here, "utf-8");
+  } catch {
+  }
+  try {
+    const nm = path2.join(process.cwd(), "node_modules", pkgName, packagedRel);
+    if (fs.existsSync(nm)) return fs.readFileSync(nm, "utf-8");
+  } catch {
+  }
+  try {
+    const alt = path2.join(process.cwd(), "dist", "index.html");
+    if (fs.existsSync(alt)) return fs.readFileSync(alt, "utf-8");
+  } catch {
+  }
+  throw new Error(
+    `ortoni-report template not found (tried:
+  - require.resolve('${pkgName}/${packagedRel}')
+  - import('module').createRequire(...).resolve('${pkgName}/${packagedRel}')
+  - relative ../dist/index.html
+  - ${path2.join(
+      process.cwd(),
+      "node_modules",
+      pkgName,
+      packagedRel
+    )}
+  - ${path2.join(process.cwd(), "dist", "index.html")}
+Ensure 'dist/index.html' is present in the published package and package.json 'files' includes 'dist/'.`
+  );
+}
+
+// src/helpers/fileManager.ts
+var FileManager = class {
+  constructor(folderPath) {
+    this.folderPath = folderPath;
+  }
+  ensureReportDirectory() {
+    const ortoniDataFolder = path3.join(this.folderPath, "ortoni-data");
+    if (!fs2.existsSync(this.folderPath)) {
+      fs2.mkdirSync(this.folderPath, { recursive: true });
+    } else {
+      if (fs2.existsSync(ortoniDataFolder)) {
+        fs2.rmSync(ortoniDataFolder, { recursive: true, force: true });
+      }
+    }
+  }
+  async writeReportFile(filename, data) {
+    let html = await readBundledTemplate();
+    const reportJSON = JSON.stringify({
+      data
+    });
+    html = html.replace("__ORTONI_TEST_REPORTDATA__", reportJSON);
+    const outputPath = path3.join(process.cwd(), this.folderPath, filename);
+    fs2.writeFileSync(outputPath, html);
+    return outputPath;
+  }
+  writeRawFile(filename, data) {
+    const outputPath = path3.join(process.cwd(), this.folderPath, filename);
+    fs2.mkdirSync(path3.dirname(outputPath), { recursive: true });
+    const content = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+    fs2.writeFileSync(outputPath, content, "utf-8");
+    return outputPath;
+  }
+  copyTraceViewerAssets(skip) {
+    if (skip) return;
+    const traceViewerFolder = path3.join(
+      __require.resolve("playwright-core"),
+      "..",
+      "lib",
+      "vite",
+      "traceViewer"
+    );
+    const traceViewerTargetFolder = path3.join(this.folderPath, "trace");
+    const traceViewerAssetsTargetFolder = path3.join(
+      traceViewerTargetFolder,
+      "assets"
+    );
+    fs2.mkdirSync(traceViewerAssetsTargetFolder, { recursive: true });
+    for (const file of fs2.readdirSync(traceViewerFolder)) {
+      if (file.endsWith(".map") || file.includes("watch") || file.includes("assets"))
+        continue;
+      fs2.copyFileSync(
+        path3.join(traceViewerFolder, file),
+        path3.join(traceViewerTargetFolder, file)
+      );
+    }
+    const assetsFolder = path3.join(traceViewerFolder, "assets");
+    for (const file of fs2.readdirSync(assetsFolder)) {
+      if (file.endsWith(".map") || file.includes("xtermModule")) continue;
+      fs2.copyFileSync(
+        path3.join(assetsFolder, file),
+        path3.join(traceViewerAssetsTargetFolder, file)
+      );
+    }
+  }
+};
+
+// src/utils/expressServer.ts
+import express from "express";
+import path4 from "path";
+import { spawn } from "child_process";
+function startReportServer(reportFolder, reportFilename, port = 2004, open2) {
+  const app = express();
+  app.use(express.static(reportFolder, { index: false }));
+  app.get("/", (_req, res) => {
+    try {
+      res.sendFile(path4.resolve(reportFolder, reportFilename));
+    } catch (error) {
+      console.error("Ortoni Report: Error sending report file:", error);
+      res.status(500).send("Error loading report");
+    }
+  });
+  try {
+    const server = app.listen(port, () => {
+      console.log(
+        `Server is running at http://localhost:${port} 
+Press Ctrl+C to stop.`
+      );
+      if (open2 === "always" || open2 === "on-failure") {
+        try {
+          openBrowser(`http://localhost:${port}`);
+        } catch (error) {
+          console.error("Ortoni Report: Error opening browser:", error);
+        }
+      }
+    });
+    server.on("error", (error) => {
+      if (error.code === "EADDRINUSE") {
+        console.error(
+          `Ortoni Report: Port ${port} is already in use. Trying a different port...`
+        );
+      } else {
+        console.error("Ortoni Report: Server error:", error);
+      }
+    });
+  } catch (error) {
+    console.error("Ortoni Report: Error starting the server:", error);
+  }
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  let command;
+  try {
+    if (platform === "win32") {
+      command = "cmd";
+      spawn(command, ["/c", "start", url]);
+    } else if (platform === "darwin") {
+      command = "open";
+      spawn(command, [url]);
+    } else {
+      command = "xdg-open";
+      spawn(command, [url]);
+    }
+  } catch (error) {
+    console.error("Ortoni Report: Error opening the browser:", error);
+  }
+}
+
 export {
   __publicField,
-  FileManager,
-  HTMLGenerator,
   normalizeFilePath,
   ensureHtmlExtension,
   escapeHtml,
   extractSuites,
-  startReportServer,
-  DatabaseManager
+  DatabaseManager,
+  HTMLGenerator,
+  FileManager,
+  startReportServer
 };