@allurereport/core 3.8.2 → 3.10.0

package/dist/utils/cli.js

@@ -0,0 +1,41 @@
+import { blue, bold, cyan } from "yoctocolors";
+const noopUploadProgressBar = {
+    tick: () => { },
+    terminate: () => { },
+};
+const isSilentLogLevel = () => {
+    const level = process.env.LOG_LEVEL ?? process.env.ALLURE_LOG_LEVEL;
+    return level === "silent";
+};
+export const createUploadProgressBarCounter = (message, total) => {
+    if (isSilentLogLevel() || total === 0 || !process.stderr.isTTY) {
+        return noopUploadProgressBar;
+    }
+    const width = 20;
+    const prefix = cyan(bold("[AllureReport]:"));
+    let current = 0;
+    let terminated = false;
+    const render = () => {
+        const ratio = total === 0 ? 1 : current / total;
+        const complete = Math.min(width, Math.round(ratio * width));
+        const bar = `${"=".repeat(complete)}${"-".repeat(width - complete)}`;
+        process.stderr.write(`\r${prefix} ${blue(message)} [${bar}] ${current}/${total}`);
+    };
+    render();
+    return {
+        tick: () => {
+            if (terminated) {
+                return;
+            }
+            current = Math.min(current + 1, total);
+            render();
+        },
+        terminate: () => {
+            if (terminated) {
+                return;
+            }
+            terminated = true;
+            process.stderr.write("\n");
+        },
+    };
+};

package/dist/utils/crypto.d.ts

@@ -1 +1,2 @@
 export declare const shortHash: () => string;
+export declare const md5: (data: string) => string;

package/dist/utils/crypto.js

@@ -1,2 +1,3 @@
-import { randomBytes } from "node:crypto";
+import { randomBytes, createHash } from "node:crypto";
 export const shortHash = () => randomBytes(8).toString("hex");
+export const md5 = (data) => createHash("md5").update(data).digest("hex");

package/dist/utils/perf.d.ts

@@ -0,0 +1,42 @@
+export declare const PERF_METRICS_FILE = "allure-perf-metrics.json";
+export type PerfMetricSpan = {
+    name: string;
+    startTimeMs: number;
+    durationMs: number;
+};
+export type PerfMetricSummary = {
+    name: string;
+    count: number;
+    totalMs: number;
+    minMs: number;
+    maxMs: number;
+    avgMs: number;
+};
+export type PerfMetricsPayload = {
+    version: 1;
+    generatedAt: string;
+    timeOriginMs: number;
+    spans: PerfMetricSpan[];
+    summary: PerfMetricSummary[];
+};
+export declare const PERF_METRIC_NAMES: {
+    readonly restoreStateTotal: "restoreState.total";
+    readonly restoreStateDump: "restoreState.dump";
+    readonly restoreStateAttachments: "restoreState.attachments";
+    readonly restoreStateStoreRestore: "restoreState.storeRestore";
+    readonly generateTotal: "generate.total";
+    readonly generateReadResults: "generate.readResults";
+    readonly generatePluginsDone: "generate.plugins.done";
+    readonly publishUploadTotal: "publish.upload.total";
+    readonly summaryGenerate: "summary.generate";
+};
+export declare const PERF_METRIC_PREFIXES: {
+    readonly generatePluginDone: "generate.plugin.done.";
+    readonly publishUploadPlugin: "publish.upload.plugin.";
+};
+export declare const isPerfMetricsEnabled: () => boolean;
+export declare const startPerfSpan: (name: string) => (() => void);
+export declare const measurePerf: <T>(name: string, fn: () => Promise<T>) => Promise<T>;
+export declare const getPerfMetricsPayload: () => PerfMetricsPayload;
+export declare const writePerfMetrics: (output: string) => Promise<boolean>;
+export declare const resetPerfMetrics: () => void;

package/dist/utils/perf.js

@@ -0,0 +1,122 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { performance } from "node:perf_hooks";
+export const PERF_METRICS_FILE = "allure-perf-metrics.json";
+const MARK_PREFIX = "allure:perf:";
+const ENABLED_VALUES = new Set(["1", "true", "yes", "on"]);
+const SPANS = [];
+const MARKS = new Set();
+const MEASURES = new Set();
+let sequence = 0;
+const round = (value) => Number(value.toFixed(3));
+export const PERF_METRIC_NAMES = {
+    restoreStateTotal: "restoreState.total",
+    restoreStateDump: "restoreState.dump",
+    restoreStateAttachments: "restoreState.attachments",
+    restoreStateStoreRestore: "restoreState.storeRestore",
+    generateTotal: "generate.total",
+    generateReadResults: "generate.readResults",
+    generatePluginsDone: "generate.plugins.done",
+    publishUploadTotal: "publish.upload.total",
+    summaryGenerate: "summary.generate",
+};
+export const PERF_METRIC_PREFIXES = {
+    generatePluginDone: "generate.plugin.done.",
+    publishUploadPlugin: "publish.upload.plugin.",
+};
+export const isPerfMetricsEnabled = () => ENABLED_VALUES.has((process.env.ALLURE_PERF_METRICS ?? "").toLowerCase());
+export const startPerfSpan = (name) => {
+    if (!isPerfMetricsEnabled()) {
+        return () => { };
+    }
+    const id = `${MARK_PREFIX}${sequence++}:${name}`;
+    const startMark = `${id}:start`;
+    const endMark = `${id}:end`;
+    let ended = false;
+    MARKS.add(startMark);
+    MARKS.add(endMark);
+    MEASURES.add(id);
+    performance.mark(startMark);
+    return () => {
+        if (ended) {
+            return;
+        }
+        ended = true;
+        performance.mark(endMark);
+        performance.measure(id, startMark, endMark);
+        const entry = performance.getEntriesByName(id, "measure").at(-1);
+        if (entry) {
+            SPANS.push({
+                name,
+                startTimeMs: round(entry.startTime),
+                durationMs: round(entry.duration),
+            });
+        }
+        performance.clearMarks(startMark);
+        performance.clearMarks(endMark);
+        performance.clearMeasures(id);
+        MARKS.delete(startMark);
+        MARKS.delete(endMark);
+        MEASURES.delete(id);
+    };
+};
+export const measurePerf = async (name, fn) => {
+    if (!isPerfMetricsEnabled()) {
+        return fn();
+    }
+    const end = startPerfSpan(name);
+    try {
+        return await fn();
+    }
+    finally {
+        end();
+    }
+};
+export const getPerfMetricsPayload = () => {
+    const byName = new Map();
+    for (const span of SPANS) {
+        const current = byName.get(span.name) ?? [];
+        current.push(span);
+        byName.set(span.name, current);
+    }
+    return {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        timeOriginMs: round(performance.timeOrigin),
+        spans: [...SPANS],
+        summary: [...byName.entries()].map(([name, group]) => {
+            const durations = group.map(({ durationMs }) => durationMs);
+            const totalMs = durations.reduce((acc, duration) => acc + duration, 0);
+            return {
+                name,
+                count: group.length,
+                totalMs: round(totalMs),
+                minMs: round(Math.min(...durations)),
+                maxMs: round(Math.max(...durations)),
+                avgMs: round(totalMs / group.length),
+            };
+        }),
+    };
+};
+export const writePerfMetrics = async (output) => {
+    if (!isPerfMetricsEnabled()) {
+        return false;
+    }
+    const payload = getPerfMetricsPayload();
+    await mkdir(output, { recursive: true });
+    await writeFile(join(output, PERF_METRICS_FILE), `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    resetPerfMetrics();
+    return true;
+};
+export const resetPerfMetrics = () => {
+    SPANS.length = 0;
+    sequence = 0;
+    for (const mark of MARKS) {
+        performance.clearMarks(mark);
+    }
+    for (const measure of MEASURES) {
+        performance.clearMeasures(measure);
+    }
+    MARKS.clear();
+    MEASURES.clear();
+};

package/dist/utils/realtimeUpdateScheduler.js

@@ -28,7 +28,12 @@ export class RealtimeUpdateScheduler {
                 await setTimeout(__classPrivateFieldGet(this, _RealtimeUpdateScheduler_cooldownMs, "f"));
                 __classPrivateFieldSet(this, _RealtimeUpdateScheduler_phase, "running", "f");
                 __classPrivateFieldSet(this, _RealtimeUpdateScheduler_dirty, false, "f");
+                const start = Date.now();
                 await __classPrivateFieldGet(this, _RealtimeUpdateScheduler_worker, "f").call(this);
+                const elapsed = Date.now() - start;
+                if (__classPrivateFieldGet(this, _RealtimeUpdateScheduler_dirty, "f") && elapsed > __classPrivateFieldGet(this, _RealtimeUpdateScheduler_cooldownMs, "f")) {
+                    await setTimeout(elapsed - __classPrivateFieldGet(this, _RealtimeUpdateScheduler_cooldownMs, "f"));
+                }
             } while (__classPrivateFieldGet(this, _RealtimeUpdateScheduler_dirty, "f"));
         });
         __classPrivateFieldSet(this, _RealtimeUpdateScheduler_worker, worker, "f");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/core",
-  "version": "3.8.2",
+  "version": "3.10.0",
   "description": "Collection of generic Allure utilities used across the entire project",
   "keywords": [
     "allure"
@@ -25,45 +25,43 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/ci": "3.8.2",
-    "@allurereport/core-api": "3.8.2",
-    "@allurereport/plugin-agent": "3.8.2",
-    "@allurereport/plugin-allure2": "3.8.2",
-    "@allurereport/plugin-api": "3.8.2",
-    "@allurereport/plugin-awesome": "3.8.2",
-    "@allurereport/plugin-classic": "3.8.2",
-    "@allurereport/plugin-csv": "3.8.2",
-    "@allurereport/plugin-dashboard": "3.8.2",
-    "@allurereport/plugin-jira": "3.8.2",
-    "@allurereport/plugin-log": "3.8.2",
-    "@allurereport/plugin-progress": "3.8.2",
-    "@allurereport/plugin-slack": "3.8.2",
-    "@allurereport/plugin-testops": "3.8.2",
-    "@allurereport/plugin-testplan": "3.8.2",
-    "@allurereport/reader": "3.8.2",
-    "@allurereport/reader-api": "3.8.2",
-    "@allurereport/service": "3.8.2",
-    "@allurereport/summary": "3.8.2",
+    "@allurereport/ci": "3.10.0",
+    "@allurereport/core-api": "3.10.0",
+    "@allurereport/plugin-agent": "3.10.0",
+    "@allurereport/plugin-allure2": "3.10.0",
+    "@allurereport/plugin-api": "3.10.0",
+    "@allurereport/plugin-awesome": "3.10.0",
+    "@allurereport/plugin-classic": "3.10.0",
+    "@allurereport/plugin-csv": "3.10.0",
+    "@allurereport/plugin-dashboard": "3.10.0",
+    "@allurereport/plugin-jira": "3.10.0",
+    "@allurereport/plugin-log": "3.10.0",
+    "@allurereport/plugin-progress": "3.10.0",
+    "@allurereport/plugin-slack": "3.10.0",
+    "@allurereport/plugin-testops": "3.10.0",
+    "@allurereport/plugin-testplan": "3.10.0",
+    "@allurereport/reader": "3.10.0",
+    "@allurereport/reader-api": "3.10.0",
+    "@allurereport/service": "3.10.0",
+    "@allurereport/summary": "3.10.0",
     "glob": "^13.0.6",
     "handlebars": "^4.7.9",
     "node-stream-zip": "^1.15.0",
-    "p-limit": "^7.2.0",
-    "progress": "^2.0.3",
+    "p-limit": "^7.3.0",
     "yaml": "^2.8.3",
     "yoctocolors": "^2.1.1",
     "zip-stream": "^7.0.2"
   },
   "devDependencies": {
-    "@types/node": "^20.17.9",
-    "@types/progress": "^2",
+    "@types/node": "^20",
     "@types/zip-stream": "^7.0.0",
-    "@vitest/runner": "^2.1.9",
+    "@vitest/runner": "^2",
     "@vitest/snapshot": "^2.1.9",
-    "allure-js-commons": "^3.3.3",
-    "allure-vitest": "^3.3.3",
-    "rimraf": "^6.0.1",
+    "allure-js-commons": "^3",
+    "allure-vitest": "^3",
+    "rimraf": "^6",
     "tslib": "^2.7.0",
-    "typescript": "^5.6.3",
-    "vitest": "^2.1.9"
+    "typescript": "^5",
+    "vitest": "^4.1.0"
   }
 }