@allurereport/web-commons 3.21.0 → 3.22.1

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;
 };
@@ -87,7 +88,7 @@ export const PREVIEWABLE_CONTENT_TYPES = [
     "text/tab-separated-values",
     "text/uri-list",
 ];
-export const isPreviewableContentType = (type) => !!type && PREVIEWABLE_CONTENT_TYPES.includes(type.split(";")[0].trim().toLowerCase());
+export const isPreviewableContentType = (type) => !!type && PREVIEWABLE_CONTENT_TYPES.includes(normalizeAttachmentContentType(type));
 const HIGHLIGHT_EXTS = new Set([
     "js",
     "mjs",
@@ -196,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":

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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/web-commons",
-  "version": "3.21.0",
+  "version": "3.22.1",
   "description": "Collection of utilities used across the web Allure reports",
   "keywords": [
     "allure",
@@ -21,16 +21,16 @@
   "scripts": {
     "build": "run clean && tsc --project ./tsconfig.json",
     "clean": "rimraf ./dist",
-    "test": "vitest run",
+    "test": "rimraf out && vp test run",
     "test:unit": "yarn test",
-    "lint": "oxlint --import-plugin src test features stories",
-    "lint:fix": "oxlint --import-plugin --fix src test features stories"
+    "lint": "vp lint --import-plugin src test features stories",
+    "lint:fix": "vp lint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/aql": "3.21.0",
-    "@allurereport/charts-api": "3.21.0",
-    "@allurereport/core-api": "3.21.0",
-    "@allurereport/plugin-api": "3.21.0",
+    "@allurereport/aql": "3.22.1",
+    "@allurereport/charts-api": "3.22.1",
+    "@allurereport/core-api": "3.22.1",
+    "@allurereport/plugin-api": "3.22.1",
     "@preact/signals": "^2.6.1",
     "@preact/signals-core": "^1.12.2",
     "ansi-to-html": "^0.7.2",
@@ -41,11 +41,11 @@
     "nanoid": "^5.1.16"
   },
   "devDependencies": {
-    "@allurereport/test-config": "3.21.0",
+    "@allurereport/common-config": "3.22.1",
     "@types/d3-interpolate": "^3.0.4",
     "@types/d3-scale": "^4.0.9",
     "@types/d3-shape": "^3.1.8",
-    "@vitest/coverage-istanbul": "^4.1.0",
+    "@vitest/coverage-istanbul": "5.0.4",
     "@vitest/runner": "^2",
     "allure-js-commons": "^3",
     "allure-vitest": "^3",
@@ -53,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"
   }
 }