@allurereport/core-api 3.2.0 → 3.4.0

package/dist/categories.d.ts

@@ -0,0 +1,108 @@
+import type { Statistic } from "./aggregate.js";
+import type { TestLabel } from "./metadata.js";
+import type { TestResult, TestStatus, TestStatusTransition } from "./model.js";
+export declare const EMPTY_VALUE = "<Empty>";
+export declare const STATUS_ORDER: Record<string, number>;
+export declare const SEVERITY_ORDER: Record<string, number>;
+export declare const TRANSITION_ORDER: Record<string, number>;
+export declare const DEFAULT_ERROR_CATEGORIES: CategoryRule[];
+export type TestCategories = {
+    roots: string[];
+    nodes: Record<string, CategoryNode>;
+};
+export type CategoryMatchingData = {
+    status: TestStatus;
+    labels: readonly TestLabel[];
+    message?: string;
+    trace?: string;
+    flaky: boolean;
+    duration?: number;
+    transition?: TestStatusTransition;
+    environment?: string;
+};
+export type ObjectMatcher = {
+    statuses?: readonly TestStatus[];
+    labels?: Record<string, string | RegExp>;
+    message?: string | RegExp;
+    trace?: string | RegExp;
+    flaky?: boolean;
+    transitions?: readonly TestStatusTransition[];
+    environments?: readonly string[];
+};
+export type PredicateMatcher = (d: CategoryMatchingData) => boolean;
+export type Matcher = ObjectMatcher | PredicateMatcher;
+export type CategoryMatcher = Matcher | readonly Matcher[];
+export type CategoryGroupBuiltInSelector = "flaky" | "owner" | "severity" | "transition" | "status" | "environment" | "layer";
+export type CategoryGroupCustomSelector = {
+    label: string;
+};
+export type CategoryGroupSelector = CategoryGroupBuiltInSelector | CategoryGroupCustomSelector;
+export type CategoryRule = {
+    id?: string;
+    name: string;
+    matchers?: CategoryMatcher;
+    groupBy?: readonly CategoryGroupSelector[];
+    groupByMessage?: boolean;
+    groupEnvironments?: boolean;
+    expand?: boolean;
+    hide?: boolean;
+    matchedStatuses?: readonly TestStatus[];
+    messageRegex?: string;
+    traceRegex?: string;
+    flaky?: boolean;
+};
+export type CategoriesStore = {
+    roots: string[];
+    nodes: Record<string, CategoryNode>;
+};
+export interface CategoryDefinition extends Pick<CategoryRule, "name" | "expand" | "hide" | "groupEnvironments"> {
+    id: string;
+    matchers: Matcher[];
+    groupBy: CategoryGroupSelector[];
+    groupByMessage: boolean;
+    index: number;
+}
+export type CategoryNodeProps = {
+    nodeId: string;
+    store: CategoriesStore;
+    activeNodeId?: string;
+    depth?: number;
+};
+export type CategoriesConfig = false | CategoryRule[] | {
+    rules: CategoryRule[];
+};
+export type CategoryNodeType = "category" | "group" | "history" | "message" | "tr";
+export type CategoryNodeItem = {
+    id: string;
+    type: CategoryNodeType;
+    name: string;
+    key?: string;
+    value?: string;
+    historyId?: string;
+    retriesCount?: number;
+    transition?: TestStatusTransition;
+    tooltips?: Record<string, string>;
+    statistic?: Statistic;
+    childrenIds?: string[];
+    testId?: string;
+    expand?: boolean;
+};
+export interface CategoryTr extends Pick<TestResult, "name" | "status" | "duration" | "id" | "flaky" | "transition"> {
+}
+export type CategoryNode = Partial<CategoryTr> & CategoryNodeItem;
+type GroupSortKey = {
+    missingRank: number;
+    primaryRank: number;
+    alphaKey: string;
+};
+export declare const normalizeCategoriesConfig: (cfg?: CategoriesConfig) => CategoryDefinition[];
+export declare const matchCategoryMatcher: (matcher: Matcher, d: CategoryMatchingData) => boolean;
+export declare const matchCategory: (categories: CategoryDefinition[], d: CategoryMatchingData) => CategoryDefinition | undefined;
+export declare const extractErrorMatchingData: (tr: Pick<TestResult, "status" | "labels" | "error" | "flaky" | "duration" | "transition" | "environment">) => CategoryMatchingData;
+export declare const buildEnvironmentSortOrder: (environmentNames: string[], defaultEnvironmentName: string) => Map<string, number>;
+export declare const compareNumbers: (left: number, right: number) => 0 | 1 | -1;
+export declare const compareStrings: (left: string, right: string) => number;
+export declare const isMissingValue: (value: string | undefined) => boolean;
+export declare const getGroupSortKey: (groupKey: string | undefined, groupValue: string | undefined, environmentOrderMap?: Map<string, number>) => GroupSortKey;
+export declare const compareChildNodes: (leftNodeId: string, rightNodeId: string, nodesById: Record<string, CategoryNode>, environmentOrderMap?: Map<string, number>) => number;
+export {};

package/dist/categories.js

@@ -0,0 +1,359 @@
+export const EMPTY_VALUE = "<Empty>";
+export const STATUS_ORDER = {
+    failed: 0,
+    broken: 1,
+    passed: 2,
+    skipped: 3,
+    unknown: 4,
+};
+export const SEVERITY_ORDER = {
+    blocker: 0,
+    critical: 1,
+    normal: 2,
+    minor: 3,
+    trivial: 4,
+};
+export const TRANSITION_ORDER = {
+    regressed: 0,
+    malfunctioned: 1,
+    new: 2,
+    fixed: 3,
+};
+export const DEFAULT_ERROR_CATEGORIES = [
+    {
+        name: "Product errors",
+        matchers: { statuses: ["failed"] },
+    },
+    {
+        name: "Test errors",
+        matchers: { statuses: ["broken"] },
+    },
+];
+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 ||
+        rule.traceRegex !== undefined ||
+        rule.flaky !== undefined;
+    if (rule.matchers !== undefined && compatKeysUsed) {
+        throw new Error(`categories[${index}] mixes canonical keys with compatibility keys`);
+    }
+    let matchers = [];
+    if (rule.matchers !== undefined) {
+        if (isMatcherArray(rule.matchers)) {
+            matchers = [...rule.matchers];
+        }
+        else {
+            matchers = [rule.matchers];
+        }
+    }
+    else if (compatKeysUsed) {
+        const compatMatcher = {};
+        if (rule.matchedStatuses) {
+            compatMatcher.statuses = rule.matchedStatuses;
+        }
+        if (rule.messageRegex !== undefined) {
+            compatMatcher.message = rule.messageRegex;
+        }
+        if (rule.traceRegex !== undefined) {
+            compatMatcher.trace = rule.traceRegex;
+        }
+        if (rule.flaky !== undefined) {
+            compatMatcher.flaky = rule.flaky;
+        }
+        matchers = [compatMatcher];
+    }
+    if (matchers.length === 0) {
+        throw new Error(`categories[${index}] must define matchers`);
+    }
+    for (let i = 0; i < matchers.length; i++) {
+        const m = matchers[i];
+        const ok = typeof m === "function" || isPlainObject(m);
+        if (!ok) {
+            throw new Error(`categories[${index}].matchers[${i}] must be object|function`);
+        }
+    }
+    return matchers;
+};
+export const normalizeCategoriesConfig = (cfg) => {
+    if (cfg === false) {
+        return [];
+    }
+    const rawRules = Array.isArray(cfg) ? cfg : (cfg?.rules ?? []);
+    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`);
+        }
+        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(normalizedId);
+        if (existing) {
+            existing.matchers.push(...matchers);
+            return;
+        }
+        const BUILT_IN_GROUP_SELECTORS = new Set([
+            "flaky",
+            "owner",
+            "severity",
+            "transition",
+            "status",
+            "environment",
+            "layer",
+        ]);
+        const groupBy = Array.isArray(rule.groupBy) ? [...rule.groupBy] : [];
+        for (const selector of groupBy) {
+            const isBuiltIn = typeof selector === "string" && BUILT_IN_GROUP_SELECTORS.has(selector);
+            const isCustom = isPlainObject(selector) &&
+                typeof selector.label === "string" &&
+                selector.label.trim().length > 0;
+            if (!isBuiltIn && !isCustom) {
+                throw new Error(`categories[${index}].groupBy contains invalid selector`);
+            }
+        }
+        const norm = {
+            id: normalizedId,
+            name: rule.name,
+            matchers,
+            groupBy,
+            groupByMessage: rule.groupByMessage ?? true,
+            groupEnvironments: rule.groupEnvironments,
+            expand: rule.expand ?? false,
+            hide: rule.hide ?? false,
+            index,
+        };
+        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) => {
+    if (m.statuses && !m.statuses.includes(d.status)) {
+        return false;
+    }
+    if (m.flaky !== undefined && m.flaky !== d.flaky) {
+        return false;
+    }
+    if (m.labels) {
+        for (const [labelName, expected] of Object.entries(m.labels)) {
+            const re = toRegExp(expected);
+            const values = d.labels.filter((l) => l.name === labelName).map((l) => l.value ?? "");
+            if (!values.some((v) => re.test(v))) {
+                return false;
+            }
+        }
+    }
+    if (m.message !== undefined) {
+        const re = toRegExp(m.message);
+        if (!re.test(d.message ?? "")) {
+            return false;
+        }
+    }
+    if (m.trace !== undefined) {
+        const re = toRegExp(m.trace);
+        if (!re.test(d.trace ?? "")) {
+            return false;
+        }
+    }
+    if (m.transitions && !m.transitions.includes(d.transition)) {
+        return false;
+    }
+    if (m.environments && !m.environments.includes(d.environment ?? EMPTY_VALUE)) {
+        return false;
+    }
+    return true;
+};
+export const matchCategoryMatcher = (matcher, d) => {
+    if (typeof matcher === "function") {
+        return matcher(d);
+    }
+    if (isPlainObject(matcher)) {
+        return matchObjectMatcher(matcher, d);
+    }
+    return false;
+};
+export const matchCategory = (categories, d) => {
+    for (const c of categories) {
+        if (c.matchers.some((m) => matchCategoryMatcher(m, d))) {
+            return c;
+        }
+    }
+    return undefined;
+};
+export const extractErrorMatchingData = (tr) => {
+    const { message, trace } = tr.error ?? {};
+    const labels = Array.isArray(tr.labels)
+        ? tr.labels.map((l) => ({ name: l.name, value: l.value ?? "" }))
+        : [];
+    return {
+        status: tr.status,
+        labels,
+        message,
+        trace,
+        flaky: tr.flaky,
+        duration: tr.duration,
+        transition: tr.transition,
+        environment: tr.environment,
+    };
+};
+export const buildEnvironmentSortOrder = (environmentNames, defaultEnvironmentName) => {
+    const orderMap = new Map();
+    for (let index = 0; index < environmentNames.length; index++) {
+        orderMap.set(environmentNames[index], index);
+    }
+    const missingEnvironmentRank = environmentNames.length;
+    const defaultEnvironmentRank = environmentNames.length + 1;
+    orderMap.set(EMPTY_VALUE, missingEnvironmentRank);
+    orderMap.set(defaultEnvironmentName, defaultEnvironmentRank);
+    return orderMap;
+};
+export const compareNumbers = (left, right) => (left < right ? -1 : left > right ? 1 : 0);
+export const compareStrings = (left, right) => left.localeCompare(right);
+export const isMissingValue = (value) => (value ?? EMPTY_VALUE) === EMPTY_VALUE;
+export const getGroupSortKey = (groupKey, groupValue, environmentOrderMap) => {
+    const normalizedValue = groupValue ?? EMPTY_VALUE;
+    const missingRank = normalizedValue === EMPTY_VALUE ? 1 : 0;
+    if (groupKey === "status") {
+        const primaryRank = STATUS_ORDER[normalizedValue] ?? 999;
+        return { primaryRank, missingRank, alphaKey: normalizedValue };
+    }
+    if (groupKey === "severity") {
+        const primaryRank = SEVERITY_ORDER[normalizedValue] ?? 999;
+        return { primaryRank, missingRank, alphaKey: normalizedValue };
+    }
+    if (groupKey === "transition") {
+        const primaryRank = TRANSITION_ORDER[normalizedValue] ?? 999;
+        return { primaryRank, missingRank, alphaKey: normalizedValue };
+    }
+    if (groupKey === "flaky") {
+        const primaryRank = normalizedValue === "true" ? 0 : 1;
+        return { primaryRank, missingRank, alphaKey: normalizedValue };
+    }
+    if (groupKey === "environment") {
+        if (environmentOrderMap) {
+            const primaryRank = environmentOrderMap.get(normalizedValue) ?? 1000;
+            return { primaryRank, missingRank: 0, alphaKey: normalizedValue };
+        }
+        return { primaryRank: 0, missingRank, alphaKey: normalizedValue };
+    }
+    return { primaryRank: 0, missingRank, alphaKey: normalizedValue };
+};
+export const compareChildNodes = (leftNodeId, rightNodeId, nodesById, environmentOrderMap) => {
+    const leftNode = nodesById[leftNodeId];
+    const rightNode = nodesById[rightNodeId];
+    const leftType = leftNode?.type ?? "";
+    const rightType = rightNode?.type ?? "";
+    if (leftType === "message" && rightType === "message") {
+        const leftTotal = leftNode.statistic?.total ?? 0;
+        const rightTotal = rightNode.statistic?.total ?? 0;
+        const byCountDescending = compareNumbers(rightTotal, leftTotal);
+        if (byCountDescending !== 0) {
+            return byCountDescending;
+        }
+        const byNameMessage = compareStrings(leftNode.name ?? "", rightNode.name ?? "");
+        if (byNameMessage !== 0) {
+            return byNameMessage;
+        }
+        return compareStrings(leftNodeId, rightNodeId);
+    }
+    if (leftType === "tr" && rightType === "tr") {
+        const leftKey = leftNode.key;
+        const rightKey = rightNode.key;
+        if (leftKey === "environment" && rightKey === "environment") {
+            const leftSortKey = getGroupSortKey("environment", leftNode.value, environmentOrderMap);
+            const rightSortKey = getGroupSortKey("environment", rightNode.value, environmentOrderMap);
+            const byPrimaryRank = compareNumbers(leftSortKey.primaryRank, rightSortKey.primaryRank);
+            if (byPrimaryRank !== 0) {
+                return byPrimaryRank;
+            }
+            const byMissingLast = compareNumbers(leftSortKey.missingRank, rightSortKey.missingRank);
+            if (byMissingLast !== 0) {
+                return byMissingLast;
+            }
+            const byAlpha = compareStrings(leftSortKey.alphaKey, rightSortKey.alphaKey);
+            if (byAlpha !== 0) {
+                return byAlpha;
+            }
+            return compareStrings(leftNodeId, rightNodeId);
+        }
+    }
+    if (leftType === "group" && rightType === "group") {
+        const leftGroupKey = leftNode.key ?? "";
+        const rightGroupKey = rightNode.key ?? "";
+        const byGroupKey = compareStrings(leftGroupKey, rightGroupKey);
+        if (byGroupKey !== 0) {
+            return byGroupKey;
+        }
+        const leftSortKey = getGroupSortKey(leftGroupKey, leftNode.value, environmentOrderMap);
+        const rightSortKey = getGroupSortKey(rightGroupKey, rightNode.value, environmentOrderMap);
+        const byPrimaryRank = compareNumbers(leftSortKey.primaryRank, rightSortKey.primaryRank);
+        if (byPrimaryRank !== 0) {
+            return byPrimaryRank;
+        }
+        const byMissingLast = compareNumbers(leftSortKey.missingRank, rightSortKey.missingRank);
+        if (byMissingLast !== 0) {
+            return byMissingLast;
+        }
+        const byAlpha = compareStrings(leftSortKey.alphaKey, rightSortKey.alphaKey);
+        if (byAlpha !== 0) {
+            return byAlpha;
+        }
+        return compareStrings(leftNodeId, rightNodeId);
+    }
+    const byType = compareStrings(leftType, rightType);
+    if (byType !== 0) {
+        return byType;
+    }
+    const byName = compareStrings(leftNode?.name ?? "", rightNode?.name ?? "");
+    if (byName !== 0) {
+        return byName;
+    }
+    return compareStrings(leftNodeId, rightNodeId);
+};

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/history.d.ts

@@ -25,6 +25,8 @@ export interface HistoryDataPoint {
     url: string;
 }
 export interface AllureHistory {
-    readHistory(branch?: string): Promise<HistoryDataPoint[]>;
-    appendHistory(history: HistoryDataPoint, branch?: string): Promise<void>;
+    readHistory(params?: {
+        branch?: string;
+    }): Promise<HistoryDataPoint[]>;
+    appendHistory(history: HistoryDataPoint): Promise<void>;
 }

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export type * from "./testCase.js";
 export type * from "./testPlan.js";
 export type * from "./config.js";
 export * from "./static.js";
+export * from "./categories.js";
 export * from "./utils/step.js";
 export type * from "./utils/tree.js";
 export * from "./utils/time.js";
@@ -21,3 +22,6 @@ export * from "./utils/status.js";
 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

@@ -1,6 +1,7 @@
 export * from "./constants.js";
 export * from "./ci.js";
 export * from "./static.js";
+export * from "./categories.js";
 export * from "./utils/step.js";
 export * from "./utils/time.js";
 export * from "./utils/comparator.js";
@@ -11,3 +12,6 @@ export * from "./utils/status.js";
 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/dictionary.d.ts

@@ -0,0 +1 @@
+export declare const createDictionary: <T>() => Record<string, T>;

package/dist/utils/dictionary.js

@@ -0,0 +1 @@
+export const createDictionary = () => Object.create(null);

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,2 +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

@@ -1,3 +1,22 @@
 export const findByLabelName = (labels, name) => {
     return labels.find((label) => label.name === name)?.value;
 };
+export const findLastByLabelName = (labels, name) => {
+    for (let i = labels.length - 1; i >= 0; i -= 1) {
+        if (labels[i].name === name) {
+            return labels[i].value;
+        }
+    }
+    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.2.0",
+  "version": "3.4.0",
   "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"