@allurereport/web-commons 3.3.0 → 3.4.0

package/dist/attachments.d.ts

@@ -29,6 +29,15 @@ export declare const blobAttachment: (id: string, ext: string, contentType: stri
 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" | "html" | "table" | "video" | "uri" | "archive" | "image-diff";
+export declare const PREVIEWABLE_CONTENT_TYPES: readonly ["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?: {
+    contentType?: string;
+    ext?: string;
+    name?: string;
+    originalFileName?: string;
+}) => boolean;
 export declare const attachmentType: (type?: string) => AttachmentType | null;
 export declare const restrictedContentTypes: string[];
 export {};

package/dist/attachments.js

@@ -65,6 +65,121 @@ export const openAttachmentInNewTab = async (id, ext, contentType) => {
     const linkUrl = URL.createObjectURL(blob);
     globalThis.open(linkUrl, "_blank");
 };
+export const PREVIEWABLE_CONTENT_TYPES = [
+    "text/html",
+    "text/csv",
+    "text/markdown",
+    "text/tab-separated-values",
+    "text/uri-list",
+];
+export const isPreviewableContentType = (type) => !!type && PREVIEWABLE_CONTENT_TYPES.includes(type);
+const HIGHLIGHT_EXTS = new Set([
+    "js",
+    "mjs",
+    "cjs",
+    "jsx",
+    "ts",
+    "mts",
+    "cts",
+    "tsx",
+    "json",
+    "html",
+    "htm",
+    "xml",
+    "css",
+    "csv",
+    "tsv",
+    "md",
+    "markdown",
+    "yaml",
+    "yml",
+    "java",
+    "py",
+    "rb",
+    "go",
+    "php",
+    "sql",
+    "kt",
+    "swift",
+    "rs",
+    "c",
+    "cpp",
+    "cs",
+    "scala",
+    "dart",
+    "lua",
+    "haskell",
+    "r",
+    "perl",
+]);
+const NO_HIGHLIGHT_TYPES = new Set(["text/plain", "text/*", "text/uri-list"]);
+const HIGHLIGHT_TYPES = new Set([
+    "text/markdown",
+    "text/html",
+    "text/csv",
+    "text/tab-separated-values",
+    "text/xml",
+    "text/json",
+    "text/yaml",
+    "text/javascript",
+    "text/typescript",
+    "text/ruby",
+    "text/python",
+    "text/php",
+    "text/java",
+    "text/csharp",
+    "text/cpp",
+    "text/c",
+    "text/go",
+    "text/rust",
+    "text/swift",
+    "text/kotlin",
+    "text/scala",
+    "text/perl",
+    "text/r",
+    "text/dart",
+    "text/lua",
+    "text/haskell",
+    "text/sql",
+    "text/x-yaml",
+    "text/css",
+    "application/yaml",
+    "application/x-yaml",
+    "application/xml",
+    "application/json",
+]);
+export const extname = (str) => {
+    const i = str.lastIndexOf(".");
+    if (i <= 0 || i === str.length - 1)
+        return undefined;
+    return str.slice(i);
+};
+export const isSyntaxHighlightSupported = (payload) => {
+    if (!payload) {
+        return false;
+    }
+    const contentType = payload.contentType?.toLowerCase();
+    let ext;
+    for (const part of [payload.ext, payload.name, payload.originalFileName]) {
+        if (!part) {
+            continue;
+        }
+        const withDot = extname(part);
+        const normalized = (withDot ?? part.replace(/^\./, "")).toLowerCase();
+        const single = normalized.includes(".") ? normalized.split(".").pop() : normalized;
+        if (single) {
+            ext = single;
+            break;
+        }
+    }
+    if (contentType && NO_HIGHLIGHT_TYPES.has(contentType)) {
+        return false;
+    }
+    if (contentType && HIGHLIGHT_TYPES.has(contentType)) {
+        return true;
+    }
+    return !!ext && HIGHLIGHT_EXTS.has(ext);
+};
 export const attachmentType = (type) => {
     switch (type) {
         case "image/bmp":

package/dist/charts/generateStabilityDistributionChart.d.ts

@@ -1,4 +1,6 @@
 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,61 +1,153 @@
 import { ChartType } from "@allurereport/charts-api";
 import { createHashStorage, createMapWithDefault } from "./utils.js";
+const DEFAULT_LIMIT = 10;
+const DEFAULT_STABILIZATION_PERIOD = 5;
 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 getStabilityRate = (passed, total) => {
-    return Math.floor((passed / total) * 10000) / 100;
+    return testResult.labels?.find((label) => label.name === labelName)?.value;
 };
 const NON_SIGNIFICANT_STATUSES = ["unknown", "skipped"];
-class IncludeAllArray extends Array {
-    constructor() {
-        super();
+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;
     }
-    includes() {
-        return true;
+    return instabilitySumNumerator / denominator;
+};
+const getStatusSequence = (historyDataPoints, tr) => {
+    let block = [];
+    for (const hdp of historyDataPoints) {
+        const htr = hdp.testResults[tr.historyId];
+        if (!htr) {
+            block = [];
+            continue;
+        }
+        if (isSignificantStatus(htr.status)) {
+            block.push(htr.status);
+        }
     }
-}
-const allValuesList = new IncludeAllArray();
+    if (isSignificantStatus(tr.status)) {
+        block.push(tr.status);
+    }
+    return block;
+};
 export const generateStabilityDistributionChart = (props) => {
     const { options, storeData } = props;
-    const { title, threshold = DEFAULT_THRESHOLD, skipStatuses = NON_SIGNIFICANT_STATUSES, groupBy = DEFAULT_GROUP_BY, groupValues = [], } = options;
-    const { testResults } = storeData;
+    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 effectiveStabilizationPeriod = Math.min(stabilizationPeriod, limit);
+    if (historyDataPoints.length < effectiveStabilizationPeriod) {
+        return {
+            data: [],
+            keys: {},
+            type: ChartType.StabilityDistribution,
+            title,
+            threshold,
+        };
+    }
+    const limitedHistoryDataPoints = historyDataPoints.slice(0, limit).sort((a, b) => a.timestamp - b.timestamp);
     const labelName = groupBy.startsWith(CUSTOM_LABEL_NAME_PREFIX)
         ? groupBy.slice(CUSTOM_LABEL_NAME_PREFIX.length)
         : groupBy;
-    const labelValuesList = groupValues.length > 0 ? groupValues : allValuesList;
-    const trsStatsByLabelValues = createMapWithDefault({
-        passed: 0,
-        total: 0,
-    });
+    const groupValuesSet = new Set(groupValues ?? []);
+    const stabilityScoresByGroup = createMapWithDefault([]);
     const keys = {};
     const hashes = createHashStorage();
+    const skipStatuses = new Set(skipStatusesList);
     for (const tr of testResults) {
-        const labelValue = getTrLabelValue(tr, labelName);
-        if (!labelValue) {
+        if (!tr.historyId) {
             continue;
         }
-        if (!labelValuesList.includes(labelValue)) {
+        if (!isSignificantStatus(tr.status)) {
             continue;
         }
-        const labelValueHash = hashes.get(labelValue);
-        keys[labelValueHash] = labelValue;
-        if (skipStatuses.includes(tr.status)) {
+        if (skipStatuses.has(tr.status)) {
+            continue;
+        }
+        const labelValue = getTrLabelValue(tr, labelName);
+        if (!labelValue || (groupValuesSet.size > 0 && !groupValuesSet.has(labelValue))) {
             continue;
         }
-        trsStatsByLabelValues.get(labelValueHash).total++;
-        if (tr.status === "passed") {
-            trsStatsByLabelValues.get(labelValueHash).passed++;
+        const statusSequence = getStatusSequence(limitedHistoryDataPoints, tr);
+        const stabilityScore = getStabilityScore(statusSequence, limit, effectiveStabilizationPeriod);
+        if (stabilityScore === undefined) {
+            continue;
         }
+        const labelValueHash = hashes.get(labelValue);
+        keys[labelValueHash] = labelValue;
+        stabilityScoresByGroup.get(labelValueHash).push(stabilityScore);
     }
     return {
-        data: trsStatsByLabelValues.entries.map(([id, { passed, total }]) => ({
-            id,
-            stabilityRate: total > 0 ? getStabilityRate(passed, total) : 0,
-        })),
+        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,

package/dist/charts/generateStatusAgePyramid.js

@@ -28,13 +28,14 @@ export const generateStatusAgePyramid = (props) => {
             statuses: STATUSES,
         };
     }
+    const currTrIds = new Set(testResults.map((tr) => tr.historyId ?? tr.id));
     const hdps = limitedHistoryPoints.map((datapoint) => ({
         ...datapoint,
         testResults: Object.values(datapoint.testResults).reduce((acc, testResult) => {
             if (!testResult.historyId) {
                 return acc;
             }
-            const isInCurrentRun = testResults.findIndex((tr) => tr.historyId === testResult.historyId) !== -1;
+            const isInCurrentRun = currTrIds.has(testResult.historyId);
             if (isInCurrentRun) {
                 acc[testResult.historyId] = testResult;
             }

package/dist/charts/generators.d.ts

@@ -1,5 +1,5 @@
 import { type ChartOptions, type GeneratedChartsData } from "@allurereport/charts-api";
-import type { TestResult } from "@allurereport/core-api";
+import { type TestResult } from "@allurereport/core-api";
 import { type AllureStore } from "@allurereport/plugin-api";
 type ChartsWidgetData = {
     general: GeneratedChartsData;

package/dist/charts/generators.js

@@ -1,5 +1,5 @@
 import { ChartType, } from "@allurereport/charts-api";
-import { DEFAULT_ENVIRONMENT } from "@allurereport/core-api";
+import { DEFAULT_ENVIRONMENT, emptyStatistic, getFallbackHistoryId, incrementStatistic, } from "@allurereport/core-api";
 import { generateCurrentStatusChart } from "./generateCurrentStatusChart.js";
 import { generateDurationDynamicsChart } from "./generateDurationDynamicsChart.js";
 import { generateDurationsChart } from "./generateDurationsChart.js";
@@ -12,13 +12,67 @@ import { generateTestingPyramidChart } from "./generateTestingPyramidChart.js";
 import { generateTrSeveritiesChart } from "./generateTrSeveritiesChart.js";
 import { generateHeatMapChart } from "./heatMap.js";
 import { generateTreeMapChart } from "./treeMap.js";
+const buildFallbackHistoryAliases = (testResults) => {
+    const aliases = new Map();
+    const ambiguousAliases = new Set();
+    for (const testResult of testResults) {
+        if (!testResult.historyId) {
+            continue;
+        }
+        const fallbackHistoryId = getFallbackHistoryId(testResult);
+        if (!fallbackHistoryId || fallbackHistoryId === testResult.historyId) {
+            continue;
+        }
+        const existingAlias = aliases.get(fallbackHistoryId);
+        if (existingAlias && existingAlias !== testResult.historyId) {
+            aliases.delete(fallbackHistoryId);
+            ambiguousAliases.add(fallbackHistoryId);
+            continue;
+        }
+        if (!ambiguousAliases.has(fallbackHistoryId)) {
+            aliases.set(fallbackHistoryId, testResult.historyId);
+        }
+    }
+    return aliases;
+};
+const normalizeHistoryDataPointsByAliases = (historyDataPoints, aliases) => {
+    if (aliases.size === 0) {
+        return historyDataPoints;
+    }
+    return historyDataPoints.map((historyDataPoint) => {
+        let testResults = historyDataPoint.testResults;
+        for (const [legacyHistoryId, primaryHistoryId] of aliases) {
+            if (!Object.prototype.hasOwnProperty.call(testResults, legacyHistoryId)) {
+                continue;
+            }
+            if (Object.prototype.hasOwnProperty.call(testResults, primaryHistoryId)) {
+                continue;
+            }
+            if (testResults === historyDataPoint.testResults) {
+                testResults = { ...testResults };
+            }
+            testResults[primaryHistoryId] = {
+                ...testResults[legacyHistoryId],
+                historyId: primaryHistoryId,
+            };
+            delete testResults[legacyHistoryId];
+        }
+        if (testResults === historyDataPoint.testResults) {
+            return historyDataPoint;
+        }
+        return {
+            ...historyDataPoint,
+            testResults,
+        };
+    });
+};
 const generateChartData = async (props) => {
-    const { env, chartsOptions, store, generateUuid, filter } = props;
+    const { envId, chartsOptions, store, generateUuid, filter } = props;
     const result = {};
     const getTrs = async () => {
         let trs = [];
-        if (env) {
-            trs = await store.testResultsByEnvironment(env);
+        if (envId) {
+            trs = await store.testResultsByEnvironmentId(envId);
         }
         else {
             trs = await store.allTestResults();
@@ -30,10 +84,12 @@ const generateChartData = async (props) => {
     };
     const getHistoryDataPoints = async () => {
         let historyDataPoints = [];
-        if (env) {
-            historyDataPoints = await store.allHistoryDataPointsByEnvironment(env);
+        if (envId) {
+            historyDataPoints = await store.allHistoryDataPointsByEnvironmentId(envId);
+        }
+        else {
+            historyDataPoints = await store.allHistoryDataPoints();
         }
-        historyDataPoints = await store.allHistoryDataPoints();
         if (typeof filter === "function") {
             historyDataPoints = historyDataPoints.map((hdp) => {
                 const trsEntries = Object.entries(hdp.testResults);
@@ -53,26 +109,21 @@ const generateChartData = async (props) => {
         }
         return historyDataPoints;
     };
-    const getStatistic = () => {
-        return store.testsStatistic((tr) => {
-            if (env && tr.environment !== env) {
-                return false;
-            }
-            if (typeof filter === "function" && !filter(tr)) {
-                return false;
-            }
-            return true;
-        });
+    const getStatistic = async () => {
+        const statistic = emptyStatistic();
+        for (const tr of await getTrs()) {
+            incrementStatistic(statistic, tr.status);
+        }
+        return statistic;
     };
-    const storeData = await Promise.all([
-        await getHistoryDataPoints(),
-        await getTrs(),
-        await getStatistic(),
-    ]).then(([historyDataPoints, testResults, statistic]) => ({
-        historyDataPoints,
-        testResults,
-        statistic,
-    }));
+    const storeData = await Promise.all([getHistoryDataPoints(), getTrs(), getStatistic()]).then(([historyDataPoints, testResults, statistic]) => {
+        const fallbackHistoryAliases = buildFallbackHistoryAliases(testResults);
+        return {
+            historyDataPoints: normalizeHistoryDataPointsByAliases(historyDataPoints, fallbackHistoryAliases),
+            testResults,
+            statistic,
+        };
+    });
     for (const chartOption of chartsOptions) {
         const chartId = generateUuid();
         switch (chartOption.type) {
@@ -122,10 +173,10 @@ const generateChartData = async (props) => {
     return result;
 };
 const hasOnlyDefaultEnvironment = (environments) => {
-    return environments.length === 1 && environments[0] === DEFAULT_ENVIRONMENT;
+    return environments.length === 1 && environments[0].id === DEFAULT_ENVIRONMENT;
 };
 export const generateCharts = async (chartsOptions, store, reportName, generateUuid, filter) => {
-    const environments = await store.allEnvironments();
+    const environments = await store.allEnvironmentIdentities();
     const chartsData = {
         general: await generateChartData({ chartsOptions, store, reportName, generateUuid, filter }),
         byEnv: {},
@@ -134,11 +185,11 @@ export const generateCharts = async (chartsOptions, store, reportName, generateU
         return chartsData;
     }
     for (const environment of environments) {
-        chartsData.byEnv[environment] = await generateChartData({
+        chartsData.byEnv[environment.id] = await generateChartData({
             chartsOptions,
             store,
             reportName,
-            env: environment,
+            envId: environment.id,
             generateUuid,
             filter,
         });

package/dist/data.js

@@ -1,3 +1,4 @@
+import { toPosixPath } from "@allurereport/core-api";
 export const ALLURE_LIVE_RELOAD_HASH_STORAGE_KEY = "__allure_report_live_reload_hash__";
 export const ensureReportDataReady = () => new Promise((resolve) => {
     const waitForReady = () => {
@@ -11,12 +12,19 @@ export const ensureReportDataReady = () => new Promise((resolve) => {
 export const loadReportData = async (name) => {
     await ensureReportDataReady();
     return new Promise((resolve, reject) => {
-        if (globalThis.allureReportData[name]) {
-            return resolve(globalThis.allureReportData[name]);
+        const dataByName = globalThis.allureReportData ?? {};
+        if (name in dataByName) {
+            return resolve(dataByName[name]);
         }
-        else {
-            return reject(new Error(`Data "${name}" not found!`));
+        const posixKey = toPosixPath(name);
+        if (posixKey in dataByName) {
+            return resolve(dataByName[posixKey]);
         }
+        const legacyBackslashKey = posixKey.replace(/\//g, "\\");
+        if (legacyBackslashKey in dataByName) {
+            return resolve(dataByName[legacyBackslashKey]);
+        }
+        return reject(new Error(`Data "${name}" not found!`));
     });
 };
 export const reportDataUrl = async (path, contentType = "application/octet-stream", params) => {
@@ -44,7 +52,13 @@ export class ReportFetchError extends Error {
     }
 }
 export const fetchReportJsonData = async (path, params) => {
-    const url = await reportDataUrl(path, undefined, params);
+    let url;
+    try {
+        url = await reportDataUrl(path, undefined, params);
+    }
+    catch {
+        throw new ReportFetchError(`Failed to fetch ${path}: data not found`, new Response(null, { status: 404, statusText: "Not Found" }));
+    }
     const res = await globalThis.fetch(url);
     if (!res.ok) {
         throw new ReportFetchError(`Failed to fetch ${url}, response status: ${res.status}`, res);

package/dist/environments.d.ts

@@ -0,0 +1,3 @@
+import type { EnvironmentIdentity } from "@allurereport/core-api";
+export declare const environmentNameById: (environments: EnvironmentIdentity[], environmentId: string) => string;
+export declare const migrateStoredEnvironmentSelection: (storedEnvironment: string, environments: EnvironmentIdentity[]) => string;

package/dist/environments.js

@@ -0,0 +1,14 @@
+export const environmentNameById = (environments, environmentId) => environments.find(({ id }) => id === environmentId)?.name ?? environmentId;
+export const migrateStoredEnvironmentSelection = (storedEnvironment, environments) => {
+    if (!storedEnvironment) {
+        return "";
+    }
+    if (environments.some(({ id }) => id === storedEnvironment)) {
+        return storedEnvironment;
+    }
+    const matches = environments.filter(({ name }) => name === storedEnvironment);
+    if (matches.length === 1) {
+        return matches[0].id;
+    }
+    return "";
+};

package/dist/i18n.d.ts

@@ -1,4 +1,4 @@
-export declare const AVAILABLE_LOCALES: readonly ["en", "en-iso", "ru", "uk", "pl", "es", "pt", "de", "hy", "az", "fr", "it", "ja", "he", "ka", "kr", "nl", "sv", "tr", "zh"];
+export declare const AVAILABLE_LOCALES: readonly ["en", "en-iso", "ru", "uk", "pl", "es", "pt", "de", "hy", "ar", "az", "fr", "it", "ja", "he", "ka", "kr", "nl", "sv", "tr", "zh", "zh-TW"];
 export declare const DEFAULT_LOCALE = "en";
 export type LangLocale = (typeof AVAILABLE_LOCALES)[number];
 export type DateTimeFormatKind = "date" | "dateTime" | "dateTimeNoSeconds";

package/dist/i18n.js

@@ -8,6 +8,7 @@ export const AVAILABLE_LOCALES = [
     "pt",
     "de",
     "hy",
+    "ar",
     "az",
     "fr",
     "it",
@@ -19,6 +20,7 @@ export const AVAILABLE_LOCALES = [
     "sv",
     "tr",
     "zh",
+    "zh-TW",
 ];
 export const DEFAULT_LOCALE = "en";
 export const LOCALE_DATE_TIME_OVERRIDES = {
@@ -110,6 +112,11 @@ export const LANG_LOCALE = {
         full: "Հայերեն",
         iso: "hy-AM",
     },
+    "ar": {
+        short: "Ar",
+        full: "العربية",
+        iso: "ar-SA",
+    },
     "az": {
         short: "Az",
         full: "Azərbaycan",
@@ -165,4 +172,9 @@ export const LANG_LOCALE = {
         full: "中文",
         iso: "zh-CN",
     },
+    "zh-TW": {
+        short: "Zh-TW",
+        full: "繁體中文",
+        iso: "zh-TW",
+    },
 };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./data.js";
 export * from "./attachments.js";
+export * from "./environments.js";
 export * from "./i18n.js";
 export * from "./charts/index.js";
 export * from "./strings.js";

package/dist/index.js

@@ -1,5 +1,6 @@
 export * from "./data.js";
 export * from "./attachments.js";
+export * from "./environments.js";
 export * from "./i18n.js";
 export * from "./charts/index.js";
 export * from "./strings.js";

package/package.json

@@ -1,60 +1,51 @@
 {
   "name": "@allurereport/web-commons",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "description": "Collection of utilities used across the web Allure reports",
   "keywords": [
     "allure",
     "testing"
   ],
-  "repository": "https://github.com/allure-framework/allure3",
   "license": "Apache-2.0",
   "author": "Qameta Software",
+  "repository": "https://github.com/allure-framework/allure3",
+  "files": [
+    "dist"
+  ],
   "type": "module",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": "./dist/index.js"
   },
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
   "scripts": {
     "build": "run clean && tsc --project ./tsconfig.json",
     "clean": "rimraf ./dist",
-    "test": "vitest run"
+    "test": "vitest run",
+    "lint": "oxlint --import-plugin src test features stories",
+    "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/aql": "3.3.0",
-    "@allurereport/charts-api": "3.3.0",
-    "@allurereport/core-api": "3.3.0",
-    "@allurereport/plugin-api": "3.3.0",
+    "@allurereport/aql": "3.4.0",
+    "@allurereport/charts-api": "3.4.0",
+    "@allurereport/core-api": "3.4.0",
+    "@allurereport/plugin-api": "3.4.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.2.6",
+    "dompurify": "^3.3.2",
     "nanoid": "^5.1.6"
   },
   "devDependencies": {
-    "@stylistic/eslint-plugin": "^2.6.1",
     "@types/d3-interpolate": "^3.0.4",
     "@types/d3-scale": "^4.0.9",
     "@types/d3-shape": "^3.1.6",
-    "@types/eslint": "^8.56.11",
-    "@typescript-eslint/eslint-plugin": "^8.0.0",
-    "@typescript-eslint/parser": "^8.0.0",
     "@vitest/runner": "^2.1.9",
     "allure-js-commons": "^3.3.0",
     "allure-vitest": "^3.3.0",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-jsdoc": "^50.0.0",
-    "eslint-plugin-n": "^17.10.1",
-    "eslint-plugin-no-null": "^1.0.2",
-    "eslint-plugin-prefer-arrow": "^1.2.3",
     "jsdom": "^26.1.0",
     "rimraf": "^6.0.1",
     "tslib": "^2.7.0",