@allurereport/core-api 3.3.1 → 3.4.1

package/dist/categories.d.ts

@@ -38,6 +38,7 @@ export type CategoryGroupCustomSelector = {
 };
 export type CategoryGroupSelector = CategoryGroupBuiltInSelector | CategoryGroupCustomSelector;
 export type CategoryRule = {
+    id?: string;
     name: string;
     matchers?: CategoryMatcher;
     groupBy?: readonly CategoryGroupSelector[];
@@ -55,6 +56,7 @@ export type CategoriesStore = {
     nodes: Record<string, CategoryNode>;
 };
 export interface CategoryDefinition extends Pick<CategoryRule, "name" | "expand" | "hide" | "groupEnvironments"> {
+    id: string;
     matchers: Matcher[];
     groupBy: CategoryGroupSelector[];
     groupByMessage: boolean;

package/dist/categories.js

@@ -32,6 +32,28 @@ export const DEFAULT_ERROR_CATEGORIES = [
 const isPlainObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
 const toRegExp = (v) => (v instanceof RegExp ? v : new RegExp(v));
 const isMatcherArray = (value) => Array.isArray(value);
+const hasControlChars = (value) => {
+    for (let index = 0; index < value.length; index++) {
+        const code = value.charCodeAt(index);
+        if (code <= 0x1f || (code >= 0x7f && code <= 0x9f)) {
+            return true;
+        }
+    }
+    return false;
+};
+const normalizeCategoryId = (id) => {
+    if (typeof id !== "string") {
+        return { valid: false, reason: "id must be a string" };
+    }
+    const normalized = id.trim();
+    if (normalized.length === 0) {
+        return { valid: false, reason: "id must not be empty" };
+    }
+    if (hasControlChars(normalized)) {
+        return { valid: false, reason: "id must not contain control characters" };
+    }
+    return { valid: true, normalized };
+};
 const normalizeMatchers = (rule, index) => {
     const compatKeysUsed = rule.matchedStatuses !== undefined ||
         rule.messageRegex !== undefined ||
@@ -85,6 +107,7 @@ export const normalizeCategoriesConfig = (cfg) => {
     const rules = rawRules.length ? rawRules : [];
     const normalized = [];
     const seen = new Map();
+    const sourceIdsByNormalizedId = new Map();
     const applyRule = (rule, index) => {
         if (!isPlainObject(rule)) {
             throw new Error(`categories[${index}] must be an object`);
@@ -92,8 +115,16 @@ export const normalizeCategoriesConfig = (cfg) => {
         if (typeof rule.name !== "string" || !rule.name.trim()) {
             throw new Error(`categories[${index}].name must be non-empty string`);
         }
+        const idValidationResult = normalizeCategoryId(rule.id ?? rule.name);
+        if (!idValidationResult.valid) {
+            throw new Error(`categories[${index}].id ${idValidationResult.reason}`);
+        }
+        const normalizedId = idValidationResult.normalized;
+        const sourceIds = sourceIdsByNormalizedId.get(normalizedId) ?? new Set();
+        sourceIds.add(rule.id ?? rule.name);
+        sourceIdsByNormalizedId.set(normalizedId, sourceIds);
         const matchers = normalizeMatchers(rule, index);
-        const existing = seen.get(rule.name);
+        const existing = seen.get(normalizedId);
         if (existing) {
             existing.matchers.push(...matchers);
             return;
@@ -118,6 +149,7 @@ export const normalizeCategoriesConfig = (cfg) => {
             }
         }
         const norm = {
+            id: normalizedId,
             name: rule.name,
             matchers,
             groupBy,
@@ -127,11 +159,19 @@ export const normalizeCategoriesConfig = (cfg) => {
             hide: rule.hide ?? false,
             index,
         };
-        seen.set(rule.name, norm);
+        seen.set(normalizedId, norm);
         normalized.push(norm);
     };
     rules.forEach(applyRule);
     DEFAULT_ERROR_CATEGORIES.forEach((rule, index) => applyRule(rule, rules.length + index));
+    sourceIdsByNormalizedId.forEach((sourceIds, normalizedId) => {
+        if (sourceIds.size <= 1) {
+            return;
+        }
+        throw new Error(`categories: normalized id ${JSON.stringify(normalizedId)} is produced by source ids [${Array.from(sourceIds)
+            .map((id) => JSON.stringify(id))
+            .join(",")}]`);
+    });
     return normalized;
 };
 const matchObjectMatcher = (m, d) => {

package/dist/constants.d.ts

@@ -3,6 +3,7 @@ import type { SeverityLevel, TestStatus } from "./model.js";
 export declare const statusesList: readonly TestStatus[];
 export declare const severityLevels: readonly SeverityLevel[];
 export declare const severityLabelName = "severity";
+export declare const fallbackTestCaseIdLabelName = "_fallbackTestCaseId";
 export declare const unsuccessfulStatuses: Set<TestStatus>;
 export declare const successfulStatuses: Set<TestStatus>;
 export declare const includedInSuccessRate: Set<TestStatus>;

package/dist/constants.js

@@ -1,6 +1,7 @@
 export const statusesList = ["failed", "broken", "passed", "skipped", "unknown"];
 export const severityLevels = ["blocker", "critical", "normal", "minor", "trivial"];
 export const severityLabelName = "severity";
+export const fallbackTestCaseIdLabelName = "_fallbackTestCaseId";
 export const unsuccessfulStatuses = new Set(["failed", "broken"]);
 export const successfulStatuses = new Set(["passed"]);
 export const includedInSuccessRate = new Set([...unsuccessfulStatuses, ...successfulStatuses]);

package/dist/environment.d.ts

@@ -3,11 +3,16 @@ export interface EnvironmentItem {
     name: string;
     values: string[];
 }
+export interface EnvironmentIdentity {
+    id: string;
+    name: string;
+}
 export type ReportVariables = Record<string, string>;
 export type EnvironmentMatcherPayload = {
     labels: TestLabel[];
 };
 export type EnvironmentDescriptor = {
+    name?: string;
     variables?: ReportVariables;
     matcher: (payload: EnvironmentMatcherPayload) => boolean;
 };

package/dist/index.d.ts

@@ -23,3 +23,5 @@ export * from "./utils/environment.js";
 export * from "./utils/history.js";
 export * from "./utils/strings.js";
 export * from "./utils/dictionary.js";
+export * from "./utils/path.js";
+export * from "./utils/url.js";

package/dist/index.js

@@ -13,3 +13,5 @@ export * from "./utils/environment.js";
 export * from "./utils/history.js";
 export * from "./utils/strings.js";
 export * from "./utils/dictionary.js";
+export * from "./utils/path.js";
+export * from "./utils/url.js";

package/dist/static.d.ts

@@ -6,6 +6,7 @@ export declare const createStylesLinkTag: (src: string) => string;
 export declare const createFontLinkTag: (src: string) => string;
 export declare const createFaviconLinkTag: (src: string) => string;
 export declare const createBaseUrlScript: () => string;
+export declare const stringifyForInlineScript: (value: unknown) => string;
 export declare const createReportDataScript: (reportFiles?: {
     name: string;
     value: string;

package/dist/static.js

@@ -23,6 +23,14 @@ export const createBaseUrlScript = () => {
     </script>
   `;
 };
+export const stringifyForInlineScript = (value) => {
+    return JSON.stringify(value)
+        .replaceAll("<", "\\u003C")
+        .replaceAll(">", "\\u003E")
+        .replaceAll("&", "\\u0026")
+        .replaceAll("\u2028", "\\u2028")
+        .replaceAll("\u2029", "\\u2029");
+};
 export const createReportDataScript = (reportFiles = []) => {
     if (!reportFiles?.length) {
         return `
@@ -31,7 +39,9 @@ export const createReportDataScript = (reportFiles = []) => {
       </script>
     `;
     }
-    const reportFilesDeclaration = reportFiles.map(({ name, value }) => `d('${name}','${value}')`).join(",");
+    const reportFilesDeclaration = reportFiles
+        .map(({ name, value }) => `d(${JSON.stringify(name)},${JSON.stringify(value)})`)
+        .join(",");
     return `
     <script async>
       window.allureReportDataReady = false;

package/dist/utils/environment.d.ts

@@ -1,5 +1,18 @@
-import type { EnvironmentsConfig } from "../environment.js";
-import type { TestEnvGroup, TestResult } from "../model.js";
+import type { EnvironmentIdentity } from "../environment.js";
+import type { TestEnvGroup } from "../model.js";
 export declare const DEFAULT_ENVIRONMENT = "default";
-export declare const matchEnvironment: (envConfig: EnvironmentsConfig, tr: Pick<TestResult, "labels">) => string;
+export declare const MAX_ENVIRONMENT_NAME_LENGTH = 64;
+export declare const MAX_ENVIRONMENT_ID_LENGTH = 64;
+export declare const DEFAULT_ENVIRONMENT_IDENTITY: EnvironmentIdentity;
+export type EnvironmentValidationResult = {
+    valid: true;
+    normalized: string;
+} | {
+    valid: false;
+    reason: string;
+};
+export declare const validateEnvironmentName: (name: unknown) => EnvironmentValidationResult;
+export declare const validateEnvironmentId: (environmentId: unknown) => EnvironmentValidationResult;
+export declare const assertValidEnvironmentName: (name: unknown, source?: string) => string;
+export declare const formatNormalizedEnvironmentCollision: (sourcePath: string, normalized: string, originalKeys: string[]) => string;
 export declare const getRealEnvsCount: (group: TestEnvGroup) => number;

package/dist/utils/environment.js

@@ -1,10 +1,80 @@
 export const DEFAULT_ENVIRONMENT = "default";
-export const matchEnvironment = (envConfig, tr) => {
-    return (Object.entries(envConfig).find(([, { matcher }]) => matcher({ labels: tr.labels }))?.[0] ?? DEFAULT_ENVIRONMENT);
+export const MAX_ENVIRONMENT_NAME_LENGTH = 64;
+export const MAX_ENVIRONMENT_ID_LENGTH = 64;
+export const DEFAULT_ENVIRONMENT_IDENTITY = {
+    id: DEFAULT_ENVIRONMENT,
+    name: DEFAULT_ENVIRONMENT,
 };
+const hasControlChars = (value) => {
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code <= 0x1f || (code >= 0x7f && code <= 0x9f)) {
+            return true;
+        }
+    }
+    return false;
+};
+const hasPathLikeSegments = (value) => {
+    if (value.includes("/") || value.includes("\\")) {
+        return true;
+    }
+    return value === "." || value === "..";
+};
+export const validateEnvironmentName = (name) => {
+    if (typeof name !== "string") {
+        return { valid: false, reason: "name must be a string" };
+    }
+    const normalized = name.trim();
+    if (normalized.length === 0) {
+        return { valid: false, reason: "name must not be empty" };
+    }
+    if (normalized.length > MAX_ENVIRONMENT_NAME_LENGTH) {
+        return {
+            valid: false,
+            reason: `name must not exceed ${MAX_ENVIRONMENT_NAME_LENGTH} characters`,
+        };
+    }
+    if (hasControlChars(normalized)) {
+        return { valid: false, reason: "name must not contain control characters" };
+    }
+    if (hasPathLikeSegments(normalized)) {
+        return { valid: false, reason: "name must not contain path-like segments" };
+    }
+    return { valid: true, normalized };
+};
+export const validateEnvironmentId = (environmentId) => {
+    if (typeof environmentId !== "string") {
+        return { valid: false, reason: "id must be a string" };
+    }
+    const normalized = environmentId.trim();
+    if (normalized.length === 0) {
+        return { valid: false, reason: "id must not be empty" };
+    }
+    if (normalized.length > MAX_ENVIRONMENT_ID_LENGTH) {
+        return {
+            valid: false,
+            reason: `id must not exceed ${MAX_ENVIRONMENT_ID_LENGTH} characters`,
+        };
+    }
+    if (!/^[A-Za-z0-9_-]+$/.test(normalized)) {
+        return {
+            valid: false,
+            reason: "id must contain only latin letters, digits, underscores, and hyphens",
+        };
+    }
+    return { valid: true, normalized };
+};
+export const assertValidEnvironmentName = (name, source = "environment name") => {
+    const validationResult = validateEnvironmentName(name);
+    if (!validationResult.valid) {
+        throw new Error(`Invalid ${source} ${JSON.stringify(name)}: ${validationResult.reason}`);
+    }
+    return validationResult.normalized;
+};
+export const formatNormalizedEnvironmentCollision = (sourcePath, normalized, originalKeys) => `${sourcePath}: normalized key ${JSON.stringify(normalized)} is produced by original keys [${originalKeys.map((key) => JSON.stringify(key)).join(",")}]`;
 export const getRealEnvsCount = (group) => {
     const { testResultsByEnv = {} } = group ?? {};
-    const envsCount = Object.keys(testResultsByEnv).length ?? 0;
+    const envsCount = Object.keys(testResultsByEnv).length;
     if (envsCount <= 1 && DEFAULT_ENVIRONMENT in testResultsByEnv) {
         return 0;
     }

package/dist/utils/history.d.ts

@@ -1,3 +1,10 @@
 import type { HistoryDataPoint, HistoryTestResult } from "../history.js";
+import type { TestParameter } from "../metadata.js";
 import type { TestResult } from "../model.js";
+export declare const stringifyHistoryParams: (parameters?: TestParameter[]) => string;
+export declare const getFallbackHistoryId: (tr: Pick<TestResult, "labels" | "parameters">) => string | undefined;
+export declare const getHistoryIdCandidates: (tr: Pick<TestResult, "historyId" | "labels" | "parameters">) => string[];
+export declare const filterUnknownByKnownIssues: (trs: TestResult[], knownIssueHistoryIds: ReadonlySet<string>) => TestResult[];
+export declare const normalizeHistoryDataPointUrls: (historyDataPoint: HistoryDataPoint) => HistoryDataPoint;
+export declare const selectHistoryTestResults: (historyDataPoints: HistoryDataPoint[], historyIdCandidates: readonly string[]) => HistoryTestResult[];
 export declare const htrsByTr: (hdps: HistoryDataPoint[], tr: TestResult | HistoryTestResult) => HistoryTestResult[];

package/dist/utils/history.js

@@ -1,22 +1,89 @@
-export const htrsByTr = (hdps, tr) => {
-    if (!tr?.historyId) {
+import { createHash } from "node:crypto";
+import { fallbackTestCaseIdLabelName } from "../constants.js";
+import { findLastByLabelName } from "./label.js";
+const md5 = (data) => createHash("md5").update(data).digest("hex");
+const parametersCompare = (a, b) => {
+    return (a.name ?? "").localeCompare(b.name ?? "") || (a.value ?? "").localeCompare(b.value ?? "");
+};
+export const stringifyHistoryParams = (parameters = []) => {
+    return [...parameters]
+        .filter((parameter) => !parameter?.excluded)
+        .sort(parametersCompare)
+        .map((parameter) => `${parameter.name}:${parameter.value}`)
+        .join(",");
+};
+export const getFallbackHistoryId = (tr) => {
+    const fallbackTestCaseId = findLastByLabelName(tr.labels ?? [], fallbackTestCaseIdLabelName);
+    if (!fallbackTestCaseId) {
+        return undefined;
+    }
+    return `${fallbackTestCaseId}.${md5(stringifyHistoryParams(tr.parameters ?? []))}`;
+};
+export const getHistoryIdCandidates = (tr) => {
+    const result = [];
+    if (tr.historyId) {
+        result.push(tr.historyId);
+    }
+    const fallbackHistoryId = getFallbackHistoryId(tr);
+    if (fallbackHistoryId && !result.includes(fallbackHistoryId)) {
+        result.push(fallbackHistoryId);
+    }
+    return result;
+};
+export const filterUnknownByKnownIssues = (trs, knownIssueHistoryIds) => {
+    return trs.filter((tr) => {
+        const historyIdCandidates = getHistoryIdCandidates(tr);
+        if (historyIdCandidates.length === 0) {
+            return true;
+        }
+        return historyIdCandidates.every((historyId) => !knownIssueHistoryIds.has(historyId));
+    });
+};
+export const normalizeHistoryDataPointUrls = (historyDataPoint) => {
+    const { url } = historyDataPoint;
+    if (!url) {
+        return historyDataPoint;
+    }
+    let testResults = historyDataPoint.testResults;
+    for (const [historyId, historyTestResult] of Object.entries(historyDataPoint.testResults)) {
+        if (historyTestResult.url) {
+            continue;
+        }
+        if (testResults === historyDataPoint.testResults) {
+            testResults = { ...historyDataPoint.testResults };
+        }
+        testResults[historyId] = {
+            ...historyTestResult,
+            url,
+        };
+    }
+    if (testResults === historyDataPoint.testResults) {
+        return historyDataPoint;
+    }
+    return {
+        ...historyDataPoint,
+        testResults,
+    };
+};
+export const selectHistoryTestResults = (historyDataPoints, historyIdCandidates) => {
+    if (historyIdCandidates.length === 0) {
         return [];
     }
-    return hdps.reduce((acc, dp) => {
-        const htr = dp.testResults[tr.historyId];
-        if (htr) {
-            if (dp.url) {
-                const url = new URL(dp.url);
-                url.hash = tr.id;
-                acc.push({
-                    ...htr,
-                    url: url.toString(),
-                });
-            }
-            else {
-                acc.push(htr);
+    return historyDataPoints.reduce((acc, historyDataPoint) => {
+        for (const historyId of historyIdCandidates) {
+            const historyTestResult = historyDataPoint.testResults[historyId];
+            if (!historyTestResult) {
+                continue;
             }
+            acc.push(historyTestResult);
+            break;
         }
         return acc;
     }, []);
 };
+export const htrsByTr = (hdps, tr) => {
+    if (!tr?.historyId) {
+        return [];
+    }
+    return selectHistoryTestResults(hdps, [tr.historyId]);
+};

package/dist/utils/label.d.ts

@@ -1,3 +1,4 @@
 import type { TestLabel } from "../index.js";
 export declare const findByLabelName: (labels: TestLabel[], name: string) => string | undefined;
 export declare const findLastByLabelName: (labels: TestLabel[], name: string) => string | undefined;
+export declare const shouldHideLabel: (labelName: string, matchers?: readonly (string | RegExp)[]) => boolean;

package/dist/utils/label.js

@@ -9,3 +9,14 @@ export const findLastByLabelName = (labels, name) => {
     }
     return undefined;
 };
+export const shouldHideLabel = (labelName, matchers = []) => {
+    if (labelName.startsWith("_")) {
+        return true;
+    }
+    return matchers.some((matcher) => {
+        if (typeof matcher === "string") {
+            return matcher === labelName;
+        }
+        return new RegExp(matcher.source, matcher.flags).test(labelName);
+    });
+};

package/dist/utils/path.d.ts

@@ -0,0 +1,2 @@
+export declare const toPosixPath: (path: string) => string;
+export declare const joinPosixPath: (...parts: string[]) => string;

package/dist/utils/path.js

@@ -0,0 +1,11 @@
+export const toPosixPath = (path) => path.replace(/\\/g, "/");
+export const joinPosixPath = (...parts) => {
+    const segments = parts.map(toPosixPath).join("/").split("/");
+    const nonEmptySegments = [];
+    for (const segment of segments) {
+        if (segment.length > 0) {
+            nonEmptySegments.push(segment);
+        }
+    }
+    return nonEmptySegments.join("/");
+};

package/dist/utils/url.d.ts

@@ -0,0 +1 @@
+export declare const sanitizeExternalUrl: (value: unknown) => string | undefined;

package/dist/utils/url.js

@@ -0,0 +1,24 @@
+const ALLOWED_EXTERNAL_URL_PROTOCOLS = new Set(["http:", "https:", "mailto:", "tel:"]);
+export const sanitizeExternalUrl = (value) => {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalized = value.trim();
+    if (normalized.length === 0) {
+        return undefined;
+    }
+    const schemeMatch = normalized.match(/^([A-Za-z][A-Za-z0-9+.-]*):/);
+    if (!schemeMatch) {
+        return undefined;
+    }
+    const protocol = `${schemeMatch[1].toLowerCase()}:`;
+    if (!ALLOWED_EXTERNAL_URL_PROTOCOLS.has(protocol)) {
+        return undefined;
+    }
+    try {
+        return new URL(normalized).toString();
+    }
+    catch {
+        return undefined;
+    }
+};

package/package.json

@@ -1,50 +1,39 @@
 {
   "name": "@allurereport/core-api",
-  "version": "3.3.1",
+  "version": "3.4.1",
   "description": "Allure Core API",
   "keywords": [
     "allure"
   ],
-  "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",
-  "exports": {
-    ".": "./dist/index.js"
-  },
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
+  "exports": {
+    ".": "./dist/index.js"
+  },
   "scripts": {
     "build": "run clean && tsc --project ./tsconfig.json",
     "clean": "rimraf ./dist",
-    "eslint": "eslint ./src/**/*.{js,jsx,ts,tsx}",
-    "eslint:format": "eslint --fix ./src/**/*.{js,jsx,ts,tsx}",
-    "test": "rimraf ./out && vitest run"
+    "test": "rimraf ./out && vitest run",
+    "lint": "oxlint --import-plugin src test features stories",
+    "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
     "d3-shape": "^3.2.0"
   },
   "devDependencies": {
-    "@stylistic/eslint-plugin": "^2.6.1",
     "@types/d3-shape": "^3.1.6",
-    "@types/eslint": "^8.56.11",
     "@types/node": "^20.17.9",
-    "@typescript-eslint/eslint-plugin": "^8.0.0",
-    "@typescript-eslint/parser": "^8.0.0",
     "@vitest/runner": "^2.1.9",
     "@vitest/snapshot": "^2.1.9",
     "allure-vitest": "^3.3.3",
-    "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",
     "rimraf": "^6.0.1",
     "typescript": "^5.6.3",
     "vitest": "^2.1.9"