@allurereport/web-commons 3.20.1 → 3.22.0

package/dist/attachments.d.ts

@@ -31,8 +31,9 @@ export declare const fetchAttachment: (id: string, ext: string, contentType?: st
 export declare const blobAttachment: (id: string, ext: string, contentType: string) => Promise<Blob>;
 export declare const downloadAttachment: (id: string, ext: string, contentType: string) => Promise<void>;
 export declare const openAttachmentInNewTab: (id: string, ext: string, contentType: string) => Promise<void>;
-export type AttachmentType = "css" | "json" | "image" | "svg" | "code" | "text" | "markdown" | "html" | "table" | "video" | "uri" | "archive" | "image-diff" | "http";
-export declare const PREVIEWABLE_CONTENT_TYPES: readonly ["text/html", "text/csv", "text/markdown", "text/tab-separated-values", "text/uri-list"];
+export type AttachmentType = "css" | "json" | "image" | "svg" | "code" | "text" | "markdown" | "html" | "table" | "video" | "uri" | "archive" | "image-diff" | "http" | "mermaid";
+export declare const MERMAID_CONTENT_TYPE = "application/vnd.allure.diagrams.mermaid";
+export declare const PREVIEWABLE_CONTENT_TYPES: readonly ["application/vnd.allure.diagrams.mermaid", "text/html", "text/csv", "text/markdown", "text/tab-separated-values", "text/uri-list"];
 export declare const isPreviewableContentType: (type?: string) => boolean;
 export declare const extname: (str: string) => string | undefined;
 export declare const isSyntaxHighlightSupported: (payload?: {

package/dist/attachments.js

@@ -1,8 +1,9 @@
+import { normalizeAttachmentContentType } from "./contentTypes.js";
 import { fetchReportAttachment } from "./data.js";
 const PLAYWRIGHT_TRACE_CONTENT_TYPE = "application/vnd.allure.playwright-trace";
 const PLAYWRIGHT_TRACE_DOWNLOAD_CONTENT_TYPE = "application/zip";
 const downloadContentType = (contentType) => {
-    return contentType.split(";")[0].trim().toLowerCase() === PLAYWRIGHT_TRACE_CONTENT_TYPE
+    return normalizeAttachmentContentType(contentType) === PLAYWRIGHT_TRACE_CONTENT_TYPE
         ? PLAYWRIGHT_TRACE_DOWNLOAD_CONTENT_TYPE
         : contentType;
 };
@@ -30,6 +31,7 @@ export const fetchAttachment = async (id, ext, contentType) => {
         case "code":
         case "html":
         case "markdown":
+        case "mermaid":
         case "table":
         case "text": {
             const text = await response.text();
@@ -77,14 +79,16 @@ export const openAttachmentInNewTab = async (id, ext, contentType) => {
     const linkUrl = URL.createObjectURL(blob);
     globalThis.open(linkUrl, "_blank");
 };
+export const MERMAID_CONTENT_TYPE = "application/vnd.allure.diagrams.mermaid";
 export const PREVIEWABLE_CONTENT_TYPES = [
+    MERMAID_CONTENT_TYPE,
     "text/html",
     "text/csv",
     "text/markdown",
     "text/tab-separated-values",
     "text/uri-list",
 ];
-export const isPreviewableContentType = (type) => !!type && PREVIEWABLE_CONTENT_TYPES.includes(type);
+export const isPreviewableContentType = (type) => !!type && PREVIEWABLE_CONTENT_TYPES.includes(normalizeAttachmentContentType(type));
 const HIGHLIGHT_EXTS = new Set([
     "js",
     "mjs",
@@ -193,7 +197,7 @@ export const isSyntaxHighlightSupported = (payload) => {
     return !!ext && HIGHLIGHT_EXTS.has(ext);
 };
 export const attachmentType = (type) => {
-    const normalizedType = type?.split(";")[0].trim().toLowerCase();
+    const normalizedType = normalizeAttachmentContentType(type);
     switch (normalizedType) {
         case "image/bmp":
         case "image/gif":
@@ -263,6 +267,8 @@ export const attachmentType = (type) => {
             return "image-diff";
         case "application/vnd.allure.http+json":
             return "http";
+        case MERMAID_CONTENT_TYPE:
+            return "mermaid";
         default:
             return null;
     }

package/dist/charts/config.d.ts

@@ -0,0 +1,2 @@
+import { type ChartOptions } from "@allurereport/charts-api";
+export declare const validateChartsOptions: (charts: ChartOptions[]) => void;

package/dist/charts/config.js

@@ -0,0 +1,15 @@
+import { ChartType } from "@allurereport/charts-api";
+export const validateChartsOptions = (charts) => {
+    for (const options of charts) {
+        if (options.type !== ChartType.StabilityDistribution) {
+            continue;
+        }
+        const { limit, stabilizationPeriod } = options;
+        if (limit !== undefined && (!Number.isInteger(limit) || limit < 0)) {
+            throw new RangeError("stabilityDistribution.limit must be a non-negative integer");
+        }
+        if (stabilizationPeriod !== undefined && (!Number.isInteger(stabilizationPeriod) || stabilizationPeriod < 1)) {
+            throw new RangeError("stabilityDistribution.stabilizationPeriod must be a positive integer");
+        }
+    }
+};

package/dist/charts/generateDurationDynamicsChart.js

@@ -43,7 +43,8 @@ const getStats = (testResults) => {
 export const generateDurationDynamicsChart = (props) => {
     const { options, storeData } = props;
     const { title, limit = DEFAULT_CHART_HISTORY_LIMIT } = options;
-    const { historyDataPoints, testResults } = storeData;
+    const { historyDataPoints } = storeData;
+    const testResults = storeData.allTestResults ?? storeData.testResults;
     const limitedHistoryPoints = limitHistoryDataPoints(historyDataPoints, limit - 1).sort((a, b) => a.timestamp - b.timestamp);
     const currentReportTimestamp = testResults.reduce((acc, testResult) => Math.max(acc, testResult.stop ?? 0), 0);
     if (limitedHistoryPoints.length === 0) {
@@ -63,7 +64,7 @@ export const generateDurationDynamicsChart = (props) => {
         ...limitedHistoryPoints,
         {
             testResults: testResults.reduce((acc, testResult) => {
-                acc[testResult.retryHash ?? testResult.id] = testResult;
+                acc[testResult.id] = testResult;
                 return acc;
             }, {}),
             uuid: "current",

package/dist/charts/generateDurationsChart.js

@@ -51,7 +51,7 @@ const getBucketsFromDurations = (durations) => {
 export const generateDurationsChart = (props) => {
     const { options, storeData } = props;
     const { groupBy = BY_NONE, title } = options;
-    const { testResults } = storeData;
+    const testResults = storeData.allTestResults ?? storeData.testResults;
     const enrichedTrs = enrichAndFilterTrs(testResults, groupBy);
     const durations = getDurations(enrichedTrs);
     const buckets = durations.size > 0 ? getBucketsFromDurations(Array.from(durations)) : [];

package/dist/charts/generateStabilityDistributionChart.d.ts

@@ -1,6 +1,4 @@
 import type { AllureChartsStoreData, StabilityDistributionChartData, StabilityDistributionChartOptions } from "@allurereport/charts-api";
-import { type TestStatus } from "@allurereport/core-api";
-export declare const getStabilityScore: (statuses: TestStatus[], historyDepth: number, stabilizationPeriod: number) => number | undefined;
 export declare const generateStabilityDistributionChart: (props: {
     options: StabilityDistributionChartOptions;
     storeData: AllureChartsStoreData;

package/dist/charts/generateStabilityDistributionChart.js

@@ -1,158 +1,63 @@
 import { ChartType } from "@allurereport/charts-api";
-import { createHistoryTestResultLookup, } from "@allurereport/core-api";
-import { createHashStorage, createMapWithDefault } from "./utils.js";
-const DEFAULT_LIMIT = 10;
-const DEFAULT_STABILIZATION_PERIOD = 5;
+import { createHistoryTestResultLookup, getTestFlakiness } from "@allurereport/core-api";
+import { createHashStorage } from "./utils.js";
 const DEFAULT_THRESHOLD = 90;
 const DEFAULT_GROUP_BY = "feature";
 const CUSTOM_LABEL_NAME_PREFIX = "label-name:";
 const SIGNIFICANT_STATUSES = new Set(["passed", "failed", "broken"]);
-const isSignificantStatus = (status) => SIGNIFICANT_STATUSES.has(status);
-const getTrLabelValue = (testResult, labelName) => {
-    return testResult.labels?.find((label) => label.name === labelName)?.value;
-};
 const NON_SIGNIFICANT_STATUSES = ["unknown", "skipped"];
-const findLatestConsecutiveSameBlock = (statuses, sequenceLength, blockSize) => {
-    for (let start = sequenceLength - blockSize; start >= 0; start--) {
-        const first = statuses[start];
-        let allSame = true;
-        for (let k = 1; k < blockSize; k++) {
-            if (statuses[start + k] !== first) {
-                allSame = false;
-                break;
-            }
-        }
-        if (allSame) {
-            return { endIndex: start + blockSize - 1, status: first };
-        }
-    }
-    return null;
-};
-const computeTransitionsInRange = (statuses, firstEdge, lastEdge) => {
-    let transitionCount = 0;
-    let firstTransitionIdx = 0;
-    let secondTransitionIdx = 0;
-    let instabilitySumNumerator = 0;
-    for (let i = firstEdge; i <= lastEdge; i++) {
-        if (statuses[i - 1] === statuses[i]) {
-            continue;
-        }
-        transitionCount++;
-        if (transitionCount === 1) {
-            firstTransitionIdx = i;
-        }
-        else if (transitionCount === 2) {
-            secondTransitionIdx = i;
-        }
-        instabilitySumNumerator += i;
-    }
-    return { transitionCount, firstTransitionIdx, secondTransitionIdx, instabilitySumNumerator };
-};
-const isRecoveryTolerancePattern = (statuses, firstTransitionIdx, secondTransitionIdx) => {
-    const s0 = statuses[firstTransitionIdx - 1];
-    const s1 = statuses[firstTransitionIdx];
-    const s2 = statuses[secondTransitionIdx - 1];
-    const s3 = statuses[secondTransitionIdx];
-    return ((s0 === "passed" && s1 === "broken" && s2 === "broken" && s3 === "passed") ||
-        (s0 === "passed" && s1 === "failed" && s2 === "failed" && s3 === "passed"));
-};
-export const getStabilityScore = (statuses, historyDepth, stabilizationPeriod) => {
-    const effectiveSequenceLength = Math.min(statuses.length, historyDepth);
-    if (effectiveSequenceLength === 0) {
-        return undefined;
-    }
-    if (effectiveSequenceLength === 1) {
-        return 1;
-    }
-    const stabilBlock = findLatestConsecutiveSameBlock(statuses, effectiveSequenceLength, stabilizationPeriod);
-    if (stabilBlock !== null && stabilBlock.endIndex === effectiveSequenceLength - 1) {
-        return 1;
-    }
-    const firstEdgeAfterStabilBlock = stabilBlock !== null ? stabilBlock.endIndex + 1 : 1;
-    const lastEdge = effectiveSequenceLength - 1;
-    const denominator = ((effectiveSequenceLength - 1) * effectiveSequenceLength) / 2;
-    const { transitionCount, firstTransitionIdx, secondTransitionIdx, instabilitySumNumerator } = computeTransitionsInRange(statuses, firstEdgeAfterStabilBlock, lastEdge);
-    if (transitionCount === 1) {
-        return 1;
-    }
-    if (transitionCount === 2 && isRecoveryTolerancePattern(statuses, firstTransitionIdx, secondTransitionIdx)) {
-        return 1;
-    }
-    return instabilitySumNumerator / denominator;
-};
-const getStatusSequence = (historyDataPoints, tr, lookupHistoryTestResult) => {
-    let block = [];
-    for (const hdp of historyDataPoints) {
-        const htr = lookupHistoryTestResult(hdp, tr);
-        if (!htr) {
-            block = [];
-            continue;
-        }
-        if (isSignificantStatus(htr.status)) {
-            block.push(htr.status);
-        }
-    }
-    if (isSignificantStatus(tr.status)) {
-        block.push(tr.status);
-    }
-    return block;
-};
 export const generateStabilityDistributionChart = (props) => {
     const { options, storeData } = props;
-    const { title, limit = DEFAULT_LIMIT, stabilizationPeriod = DEFAULT_STABILIZATION_PERIOD, threshold = DEFAULT_THRESHOLD, skipStatuses: skipStatusesList = NON_SIGNIFICANT_STATUSES, groupBy = DEFAULT_GROUP_BY, groupValues = [], } = options;
-    const { testResults, historyDataPoints } = storeData;
-    const lookupHistoryTestResult = createHistoryTestResultLookup(storeData.allTestResults ?? testResults);
-    const effectiveStabilizationPeriod = Math.min(stabilizationPeriod, limit);
-    if (historyDataPoints.length < effectiveStabilizationPeriod) {
-        return {
-            data: [],
-            keys: {},
-            type: ChartType.StabilityDistribution,
-            title,
-            threshold,
-        };
+    const { title, limit, stabilizationPeriod, threshold = DEFAULT_THRESHOLD, skipStatuses: skipStatusesList = NON_SIGNIFICANT_STATUSES, groupBy = DEFAULT_GROUP_BY, groupValues = [], } = options;
+    const chart = {
+        data: [],
+        keys: {},
+        type: ChartType.StabilityDistribution,
+        title,
+        threshold,
+    };
+    if (limit === 0) {
+        return chart;
     }
-    const limitedHistoryDataPoints = historyDataPoints.slice(0, limit).sort((a, b) => a.timestamp - b.timestamp);
+    const { testResults, historyDataPoints } = storeData;
+    const lookup = createHistoryTestResultLookup(storeData.allTestResults ?? testResults);
+    const history = [...historyDataPoints].sort((a, b) => b.timestamp - a.timestamp);
     const labelName = groupBy.startsWith(CUSTOM_LABEL_NAME_PREFIX)
         ? groupBy.slice(CUSTOM_LABEL_NAME_PREFIX.length)
         : groupBy;
     const groupValuesSet = new Set(groupValues ?? []);
-    const stabilityScoresByGroup = createMapWithDefault([]);
-    const keys = {};
+    const groups = new Map();
     const hashes = createHashStorage();
     const skipStatuses = new Set(skipStatusesList);
     for (const tr of testResults) {
-        if (!tr.retryHash) {
+        if (!SIGNIFICANT_STATUSES.has(tr.status) || skipStatuses.has(tr.status)) {
             continue;
         }
-        if (!isSignificantStatus(tr.status)) {
+        const labelValue = tr.labels?.find((label) => label.name === labelName)?.value;
+        if (!labelValue || (groupValuesSet.size > 0 && !groupValuesSet.has(labelValue))) {
             continue;
         }
-        if (skipStatuses.has(tr.status)) {
+        const flaky = tr.sourceMetadata?.reportedFlaky === true
+            ? true
+            : getTestFlakiness(tr, history.map((point) => lookup(point, tr)), { historyDepth: limit, stabilizationPeriod });
+        if (flaky === undefined) {
             continue;
         }
-        const labelValue = getTrLabelValue(tr, labelName);
-        if (!labelValue || (groupValuesSet.size > 0 && !groupValuesSet.has(labelValue))) {
-            continue;
+        const id = hashes.get(labelValue);
+        let counts = groups.get(id);
+        if (!counts) {
+            counts = { stable: 0, assessed: 0 };
+            groups.set(id, counts);
+            chart.keys[id] = labelValue;
         }
-        const statusSequence = getStatusSequence(limitedHistoryDataPoints, tr, lookupHistoryTestResult);
-        const stabilityScore = getStabilityScore(statusSequence, limit, effectiveStabilizationPeriod);
-        if (stabilityScore === undefined) {
-            continue;
+        counts.assessed++;
+        if (!flaky) {
+            counts.stable++;
         }
-        const labelValueHash = hashes.get(labelValue);
-        keys[labelValueHash] = labelValue;
-        stabilityScoresByGroup.get(labelValueHash).push(stabilityScore);
     }
-    return {
-        data: stabilityScoresByGroup.entries.map(([id, scores]) => {
-            const avg = scores.length > 0 ? scores.reduce((a, b) => a + b, 0) / scores.length : 0;
-            const stabilityRate = Math.floor(avg * 10000) / 100;
-            return { id, stabilityRate };
-        }),
-        keys,
-        type: ChartType.StabilityDistribution,
-        title,
-        threshold,
-    };
+    chart.data = [...groups].map(([id, counts]) => ({
+        id,
+        stabilityRate: Math.floor((counts.stable * 10000) / counts.assessed) / 100,
+    }));
+    return chart;
 };

package/dist/charts/generators.js

@@ -28,6 +28,19 @@ const generateChartData = async (props) => {
         }
         return trs;
     };
+    const getAllTrs = async () => {
+        let trs = [];
+        if (envId) {
+            trs = await store.testResultsByEnvironmentId(envId, { includeRetries: true });
+        }
+        else {
+            trs = await store.allTestResults({ includeRetries: true });
+        }
+        if (filter) {
+            trs = trs.filter(filter);
+        }
+        return trs;
+    };
     const getHistoryDataPoints = async () => {
         let historyDataPoints = [];
         if (envId) {
@@ -43,7 +56,7 @@ const generateChartData = async (props) => {
                     try {
                         return filter(tr);
                     }
-                    catch (error) {
+                    catch {
                         return false;
                     }
                 });
@@ -66,7 +79,7 @@ const generateChartData = async (props) => {
         getHistoryDataPoints(),
         getTrs(),
         getStatistic(),
-        store.allTestResults({ includeRetries: true }),
+        getAllTrs(),
     ]).then(([historyDataPoints, testResults, statistic, allTestResults]) => ({
         historyDataPoints,
         testResults,

package/dist/charts/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./utils.js";
+export * from "./config.js";
 export type * from "./types.js";
 export * from "./colors.js";
 export * from "./chart-utils.js";

package/dist/charts/index.js

@@ -1,4 +1,5 @@
 export * from "./utils.js";
+export * from "./config.js";
 export * from "./colors.js";
 export * from "./chart-utils.js";
 export * from "./line.js";

package/dist/contentTypes.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeAttachmentContentType(type: string): string;
+export declare function normalizeAttachmentContentType(type?: null | undefined): undefined;
+export declare function normalizeAttachmentContentType(type?: string | null): string | undefined;
+export declare const isJsonAttachmentContentType: (type: string) => boolean;
+export declare const isHtmlAttachmentContentType: (type: string) => boolean;

package/dist/contentTypes.js

@@ -0,0 +1,11 @@
+export function normalizeAttachmentContentType(type) {
+    return type?.split(";")[0].trim().toLowerCase();
+}
+export const isJsonAttachmentContentType = (type) => {
+    const normalized = normalizeAttachmentContentType(type);
+    return normalized === "application/json" || normalized === "text/json" || normalized.endsWith("+json");
+};
+export const isHtmlAttachmentContentType = (type) => {
+    const normalized = normalizeAttachmentContentType(type);
+    return normalized === "text/html" || normalized === "application/xhtml+xml";
+};

package/dist/httpAttachments.d.ts

@@ -0,0 +1,79 @@
+export declare const HTTP_EXCHANGE_REDACTED_VALUE = "__ALLURE_REDACTED__";
+export type HttpPair = {
+    name: string;
+    value: string;
+    masked: boolean;
+};
+export type HttpCookie = HttpPair & {
+    domain: string;
+    expires: string;
+    httpOnly: boolean;
+    maxAge?: number;
+    path: string;
+    sameSite: string;
+    secure: boolean;
+};
+export type HttpStream = {
+    type: string;
+    complete: string;
+    chunkCount?: number;
+};
+export type HttpBodyPart = {
+    name: string;
+    fileName: string;
+    headers: HttpPair[];
+    contentType: string;
+    encoding: string;
+    value: string;
+    hasValue: boolean;
+    size?: number;
+    truncated: boolean;
+};
+export type HttpBody = {
+    contentType: string;
+    encoding: string;
+    value: string;
+    hasValue: boolean;
+    size?: number;
+    truncated: boolean;
+    form: HttpPair[];
+    parts: HttpBodyPart[];
+    stream: HttpStream | null;
+};
+export type HttpRequest = {
+    method: string;
+    url: string;
+    httpVersion: string;
+    headers: HttpPair[];
+    cookies: HttpCookie[];
+    query: HttpPair[];
+    body: HttpBody | null;
+    trailers: HttpPair[];
+};
+export type HttpInformationalResponse = {
+    status: string;
+    reason: string;
+    headers: HttpPair[];
+};
+export type HttpResponse = {
+    status: string;
+    reason: string;
+    httpVersion: string;
+    headers: HttpPair[];
+    cookies: HttpCookie[];
+    body: HttpBody | null;
+    trailers: HttpPair[];
+    informationalResponses: HttpInformationalResponse[];
+};
+export type HttpError = {
+    name: string;
+    message: string;
+    stack: string;
+};
+export type NormalizedHttpPayload = {
+    request: HttpRequest | null;
+    response: HttpResponse | null;
+    error: HttpError | null;
+    durationMs: string;
+};
+export declare const normalizeHttpExchangePayload: (payload: unknown) => NormalizedHttpPayload;

package/dist/httpAttachments.js

@@ -0,0 +1,160 @@
+export const HTTP_EXCHANGE_REDACTED_VALUE = "__ALLURE_REDACTED__";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const toOptionalString = (value) => value === null || typeof value === "undefined" ? "" : String(value);
+const toFiniteNumber = (value) => {
+    const num = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : NaN;
+    return Number.isFinite(num) ? num : undefined;
+};
+const headerValue = (headers, name) => {
+    const normalizedName = name.toLowerCase();
+    return headers.find((header) => header.name.toLowerCase() === normalizedName)?.value ?? "";
+};
+const normalizeArray = (value, normalize) => Array.isArray(value) ? value.map(normalize).filter((item) => item !== null) : [];
+const normalizePair = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const name = toOptionalString(value.name).trim();
+    const pairValue = toOptionalString(value.value);
+    const masked = pairValue === HTTP_EXCHANGE_REDACTED_VALUE;
+    if (!name && !pairValue) {
+        return null;
+    }
+    return { name, value: pairValue, masked };
+};
+const normalizePairs = (value) => normalizeArray(value, normalizePair);
+const normalizeCookie = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const pair = normalizePair(value);
+    if (!pair) {
+        return null;
+    }
+    return {
+        ...pair,
+        domain: toOptionalString(value.domain).trim(),
+        expires: toOptionalString(value.expires).trim(),
+        httpOnly: value.httpOnly === true,
+        maxAge: toFiniteNumber(value.maxAge),
+        path: toOptionalString(value.path).trim(),
+        sameSite: toOptionalString(value.sameSite).trim(),
+        secure: value.secure === true,
+    };
+};
+const normalizeCookies = (value) => normalizeArray(value, normalizeCookie);
+const normalizeStream = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    return {
+        type: toOptionalString(value.type).trim(),
+        complete: typeof value.complete === "boolean" ? String(value.complete) : "",
+        chunkCount: toFiniteNumber(value.chunkCount),
+    };
+};
+const normalizeBodyPart = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const headers = normalizePairs(value.headers);
+    const hasValue = typeof value.value !== "undefined" && value.value !== null;
+    return {
+        name: toOptionalString(value.name).trim(),
+        fileName: toOptionalString(value.fileName).trim(),
+        headers,
+        contentType: toOptionalString(value.contentType).trim() || headerValue(headers, "content-type"),
+        encoding: toOptionalString(value.encoding).trim().toLowerCase() || "utf8",
+        value: hasValue ? String(value.value) : "",
+        hasValue,
+        size: toFiniteNumber(value.size),
+        truncated: value.truncated === true,
+    };
+};
+const normalizeBodyParts = (value) => normalizeArray(value, normalizeBodyPart);
+const normalizeBody = (value, fallbackContentType = "") => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const hasValue = typeof value.value !== "undefined" && value.value !== null;
+    return {
+        contentType: toOptionalString(value.contentType).trim() || fallbackContentType,
+        encoding: toOptionalString(value.encoding).trim().toLowerCase() || "utf8",
+        value: hasValue ? String(value.value) : "",
+        hasValue,
+        size: toFiniteNumber(value.size),
+        truncated: value.truncated === true,
+        form: normalizePairs(value.form),
+        parts: normalizeBodyParts(value.parts),
+        stream: normalizeStream(value.stream),
+    };
+};
+const normalizeRequest = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const headers = normalizePairs(value.headers);
+    return {
+        method: toOptionalString(value.method).trim().toUpperCase() || "GET",
+        url: toOptionalString(value.url).trim(),
+        httpVersion: toOptionalString(value.httpVersion).trim(),
+        headers,
+        cookies: normalizeCookies(value.cookies),
+        query: normalizePairs(value.query),
+        body: normalizeBody(value.body, headerValue(headers, "content-type")),
+        trailers: normalizePairs(value.trailers),
+    };
+};
+const normalizeInformationalResponse = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    return {
+        status: toOptionalString(value.status).trim(),
+        reason: toOptionalString(value.statusText).trim(),
+        headers: normalizePairs(value.headers),
+    };
+};
+const normalizeInformationalResponses = (value) => normalizeArray(value, normalizeInformationalResponse);
+const normalizeResponse = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const headers = normalizePairs(value.headers);
+    return {
+        status: toOptionalString(value.status).trim(),
+        reason: toOptionalString(value.statusText).trim(),
+        httpVersion: toOptionalString(value.httpVersion).trim(),
+        headers,
+        cookies: normalizeCookies(value.cookies),
+        body: normalizeBody(value.body, headerValue(headers, "content-type")),
+        trailers: normalizePairs(value.trailers),
+        informationalResponses: normalizeInformationalResponses(value.informationalResponses),
+    };
+};
+const normalizeError = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const name = toOptionalString(value.name).trim();
+    const message = toOptionalString(value.message).trim();
+    const stack = toOptionalString(value.stack).trim();
+    if (!name && !message && !stack) {
+        return null;
+    }
+    return { name, message, stack };
+};
+export const normalizeHttpExchangePayload = (payload) => {
+    if (!isRecord(payload)) {
+        return { request: null, response: null, error: null, durationMs: "" };
+    }
+    const start = toFiniteNumber(payload.start);
+    const stop = toFiniteNumber(payload.stop);
+    const durationMs = start !== undefined && stop !== undefined && stop >= start ? `${stop - start} ms` : "";
+    return {
+        request: normalizeRequest(payload.request),
+        response: normalizeResponse(payload.response),
+        error: normalizeError(payload.error),
+        durationMs,
+    };
+};

package/dist/index.d.ts

@@ -19,3 +19,6 @@ export * from "./treeSubtreeToggle.js";
 export * from "./subtreeExpansion.js";
 export * from "./hotkeys/index.js";
 export * from "./treeNavigation/index.js";
+export * from "./platform.js";
+export * from "./contentTypes.js";
+export * from "./httpAttachments.js";

package/dist/index.js

@@ -19,3 +19,6 @@ export * from "./treeSubtreeToggle.js";
 export * from "./subtreeExpansion.js";
 export * from "./hotkeys/index.js";
 export * from "./treeNavigation/index.js";
+export * from "./platform.js";
+export * from "./contentTypes.js";
+export * from "./httpAttachments.js";

package/dist/platform.d.ts

@@ -0,0 +1 @@
+export declare const testPlatform: (re: RegExp) => boolean;

package/dist/platform.js

@@ -0,0 +1,8 @@
+export const testPlatform = (re) => {
+    if (typeof window === "undefined") {
+        return false;
+    }
+    const navigator = window?.navigator;
+    const platform = navigator?.userAgentData?.platform ?? navigator?.platform;
+    return platform ? re.test(platform) : false;
+};

package/dist/stores/url/store.d.ts

@@ -14,6 +14,3 @@ export declare const currentUrl: import("@preact/signals-core").ReadonlySignal<{
 export declare const getParamValue: (key: string) => string | null;
 export declare const getParamValues: (key: string) => string[];
 export declare const hasParam: (key: string) => boolean;
-export declare const getParamValueComputed: (key: string) => import("@preact/signals-core").ReadonlySignal<string | null>;
-export declare const getParamValuesComputed: (key: string) => import("@preact/signals-core").ReadonlySignal<string[]>;
-export declare const hasParamComputed: (key: string) => import("@preact/signals-core").ReadonlySignal<boolean>;

package/dist/stores/url/store.js

@@ -40,6 +40,3 @@ export const currentUrl = computed(() => {
 export const getParamValue = (key) => urlSearchParams.value.get(key);
 export const getParamValues = (key) => urlSearchParams.value.getAll(key);
 export const hasParam = (key) => urlSearchParams.value.has(key);
-export const getParamValueComputed = (key) => computed(() => getParamValue(key));
-export const getParamValuesComputed = (key) => computed(() => getParamValues(key));
-export const hasParamComputed = (key) => computed(() => hasParam(key));

package/dist/treeSubtreeToggle.d.ts

@@ -7,19 +7,18 @@ export type SubtreeNodeState = {
 };
 export declare const isSubtreeFirstLevelOnlyOpened: (rootId: string, rootOpenedByDefault: boolean, subtreeNodes: SubtreeNodeState[], isNodeOpened: (id: string, openedByDefault: boolean) => boolean) => boolean;
 export declare const isSubtreeExpandedAll: (subtreeNodes: SubtreeNodeState[], isNodeOpened: (id: string, openedByDefault: boolean) => boolean) => boolean;
-export declare const getNextSubtreeToggleState: (payload: {
+export type SubtreeTogglePayload = {
     hasOnlyLeafResults: boolean;
     isSubtreeCollapsedAll: boolean;
     isSubtreeFirstLevelOnly: boolean;
     isSubtreeExpandedAll: boolean;
     lastSubtreeToggle: SubtreeToggleState | null;
-}) => SubtreeToggleState;
+};
+export declare const getNextSubtreeToggleState: (payload: SubtreeTogglePayload) => SubtreeToggleState;
+export type SubtreeToggleAction = "expand-first-level" | "collapse-to-first-level" | "expand-all" | "collapse-all";
+export declare const getSubtreeToggleAction: (payload: SubtreeTogglePayload) => SubtreeToggleAction;
 export declare const resolveNextSubtreeToggleState: (subtreeNodes: SubtreeNodeState[], isNodeOpened: (id: string, openedByDefault: boolean) => boolean, lastSubtreeToggle: SubtreeToggleState | null) => {
     nextState: SubtreeToggleState;
     nextLastToggle: SubtreeToggleState | null;
 };
-export declare const getSubtreeToggleIcon: (payload: {
-    hasOnlyLeafResults: boolean;
-    isSubtreeCollapsedAll: boolean;
-    isSubtreeFirstLevelOnly: boolean;
-}) => SubtreeToggleIconState;
+export declare const getSubtreeToggleIcon: (payload: SubtreeTogglePayload) => SubtreeToggleIconState;

package/dist/treeSubtreeToggle.js

@@ -21,6 +21,16 @@ export const getNextSubtreeToggleState = (payload) => {
     }
     return "all";
 };
+export const getSubtreeToggleAction = (payload) => {
+    const nextState = getNextSubtreeToggleState(payload);
+    if (nextState === "all") {
+        return "expand-all";
+    }
+    if (nextState === "none") {
+        return "collapse-all";
+    }
+    return payload.isSubtreeCollapsedAll ? "expand-first-level" : "collapse-to-first-level";
+};
 export const resolveNextSubtreeToggleState = (subtreeNodes, isNodeOpened, lastSubtreeToggle) => {
     const root = subtreeNodes.find((node) => node.isRoot);
     if (!root || subtreeNodes.length === 0) {
@@ -43,15 +53,14 @@ export const resolveNextSubtreeToggleState = (subtreeNodes, isNodeOpened, lastSu
     };
 };
 export const getSubtreeToggleIcon = (payload) => {
-    const { hasOnlyLeafResults, isSubtreeCollapsedAll, isSubtreeFirstLevelOnly } = payload;
-    if (hasOnlyLeafResults) {
-        return isSubtreeCollapsedAll ? "single-down" : "single-up";
-    }
-    if (isSubtreeCollapsedAll) {
-        return "single-down";
-    }
-    if (isSubtreeFirstLevelOnly) {
-        return "double-down";
+    switch (getSubtreeToggleAction(payload)) {
+        case "expand-first-level":
+            return "single-down";
+        case "expand-all":
+            return payload.hasOnlyLeafResults ? "single-down" : "double-down";
+        case "collapse-to-first-level":
+            return "double-up";
+        case "collapse-all":
+            return "single-up";
     }
-    return "double-up";
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/web-commons",
-  "version": "3.20.1",
+  "version": "3.22.0",
   "description": "Collection of utilities used across the web Allure reports",
   "keywords": [
     "allure",
@@ -21,28 +21,31 @@
   "scripts": {
     "build": "run clean && tsc --project ./tsconfig.json",
     "clean": "rimraf ./dist",
-    "test": "vitest run",
-    "lint": "oxlint --import-plugin src test features stories",
-    "lint:fix": "oxlint --import-plugin --fix src test features stories"
+    "test": "rimraf out && vp test run",
+    "test:unit": "yarn test",
+    "lint": "vp lint --import-plugin src test features stories",
+    "lint:fix": "vp lint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/aql": "3.20.1",
-    "@allurereport/charts-api": "3.20.1",
-    "@allurereport/core-api": "3.20.1",
-    "@allurereport/plugin-api": "3.20.1",
+    "@allurereport/aql": "3.22.0",
+    "@allurereport/charts-api": "3.22.0",
+    "@allurereport/core-api": "3.22.0",
+    "@allurereport/plugin-api": "3.22.0",
     "@preact/signals": "^2.6.1",
     "@preact/signals-core": "^1.12.2",
     "ansi-to-html": "^0.7.2",
     "d3-interpolate": "^3.0.1",
     "d3-scale": "^4.0.2",
     "d3-shape": "^3.2.0",
-    "dompurify": "^3.4.0",
+    "dompurify": "3.4.16",
     "nanoid": "^5.1.16"
   },
   "devDependencies": {
+    "@allurereport/common-config": "3.22.0",
     "@types/d3-interpolate": "^3.0.4",
     "@types/d3-scale": "^4.0.9",
     "@types/d3-shape": "^3.1.8",
+    "@vitest/coverage-istanbul": "5.0.4",
     "@vitest/runner": "^2",
     "allure-js-commons": "^3",
     "allure-vitest": "^3",
@@ -50,6 +53,8 @@
     "rimraf": "^6",
     "tslib": "^2.7.0",
     "typescript": "^5",
-    "vitest": "^4.1.0"
+    "vite": "@voidzero-dev/vite-plus-core@1.2.0",
+    "vite-plus": "1.2.0",
+    "vitest": "5.0.4"
   }
 }