@allurereport/reader 3.0.0-beta.10

package/dist/xcresult/index.js

@@ -0,0 +1,91 @@
+import console from "node:console";
+import { IS_MAC, XCRESULTTOOL_MISSING_MESSAGE, isXcResultBundle } from "./bundle.js";
+import { version } from "./xcresulttool/cli.js";
+import LegacyApiParser from "./xcresulttool/legacy/index.js";
+import { parseWithExportedAttachments } from "./xcresulttool/utils.js";
+const readerId = "xcresult";
+export const readXcResultBundle = async (visitor, directory) => {
+    if (await isXcResultBundle(directory)) {
+        if (!IS_MAC) {
+            console.warn(`It looks like ${directory} is a Mac OS bundle. Allure 3 can only parse such bundles on a Mac OS machine.`);
+            return false;
+        }
+        const xcResultToolVersion = await maybeGetXcResultToolVersion();
+        if (xcResultToolVersion) {
+            return await parseBundleWithXcResultTool(visitor, directory, xcResultToolVersion);
+        }
+        return true;
+    }
+    return false;
+};
+const maybeGetXcResultToolVersion = async () => {
+    try {
+        return await version();
+    }
+    catch (e) {
+        console.error(XCRESULTTOOL_MISSING_MESSAGE);
+        console.error(e);
+    }
+};
+const parseBundleWithXcResultTool = async (visitor, xcResultPath, xcResultToolVersion) => {
+    try {
+        if (isXcode16OrNewer(xcResultToolVersion)) {
+            await parseWithXcode16OrNewer(visitor, xcResultPath, xcResultToolVersion);
+        }
+        else {
+            await parseWithXcode15OrOlder(visitor, xcResultPath);
+        }
+        return true;
+    }
+    catch (e) {
+        console.error("error parsing", xcResultPath, e);
+    }
+    return false;
+};
+const parseWithXcode15OrOlder = async (visitor, xcResultPath) => {
+    const legacyApiParser = new LegacyApiParser({
+        xcResultPath,
+        xcode16Plus: false,
+    });
+    await tryApi(visitor, xcResultPath, legacyApiParser);
+};
+const parseWithXcode16OrNewer = async (visitor, xcResultPath, xcResultToolVersion) => {
+    await parseWithExportedAttachments(xcResultPath, async (createAttachmentFile) => {
+        const legacyApiParser = new LegacyApiParser({
+            xcResultPath,
+            createAttachmentFile,
+            xcode16Plus: true,
+        });
+        try {
+            await tryApi(visitor, xcResultPath, legacyApiParser);
+            return;
+        }
+        catch (e) {
+            console.error(e);
+            if (legacyApiParser.legacyApiSucceeded()) {
+                throw e;
+            }
+        }
+        throw new Error(`The legacy xcresulttool API can't be accessed in ${xcResultToolVersion}. ` +
+            "The new API is not yet supported by the reader. " +
+            "Please, see https://github.com/allure-framework/allure3/issues/110 for more details");
+    });
+};
+const tryApi = async (visitor, originalFileName, apiParser) => {
+    for await (const x of apiParser.parse()) {
+        if ("readContent" in x) {
+            await visitor.visitAttachmentFile(x, { readerId });
+        }
+        else {
+            visitor.visitTestResult(x, { readerId, metadata: { originalFileName } });
+        }
+    }
+};
+const isXcode16OrNewer = (versionText) => {
+    const versionMatch = versionText.match(/xcresulttool version (\d+)/);
+    if (versionMatch) {
+        const xcResultToolVersion = parseInt(versionMatch[1], 10);
+        return xcResultToolVersion >= 23000;
+    }
+    return false;
+};

package/dist/xcresult/model.d.ts

@@ -0,0 +1,61 @@
+import type { RawTestLabel, RawTestLink, RawTestParameter } from "@allurereport/reader-api";
+import type { XcTestResult } from "./xcresulttool/xcModel.js";
+export type XcAttachments = Map<string, XcAttachmentMetadata[]>;
+export type XcAttachmentMetadata = {
+    path: string;
+    name?: string;
+    timestamp?: number;
+};
+export type TestDetailsRunData = {
+    duration?: number;
+    result?: XcTestResult;
+    parameters?: (string | undefined)[];
+    emitted?: boolean;
+};
+export type TestRunCoordinates = {
+    device?: string;
+    testPlan?: string;
+    attempt?: number;
+    args?: TestRunArgs;
+};
+export type TestRunArgs = ({
+    parameter: string;
+    value: string;
+} | undefined)[];
+export type TestRunSelector = {
+    device?: string;
+    testPlan?: string;
+    attempt?: number;
+    args?: (string | undefined)[];
+};
+export type TestRunLookup<Data> = Map<string, Map<string, Map<string, Data[]>>>;
+export type TargetDescriptor = {
+    model?: string;
+    architecture?: string;
+    platform?: string;
+    osVersion?: string;
+};
+export type AllureApiCallBase<Type extends string, Value> = {
+    type: Type;
+    value: Value;
+};
+export type AllureNameApiCall = AllureApiCallBase<"name", string>;
+export type AllureDescriptionApiCall = AllureApiCallBase<"description", string>;
+export type AllurePreconditionApiCall = AllureApiCallBase<"precondition", string>;
+export type AllureExpectedResultApiCall = AllureApiCallBase<"expectedResult", string>;
+export type AllureLabelApiCall = AllureApiCallBase<"label", RawTestLabel>;
+export type AllureLinkApiCall = AllureApiCallBase<"link", RawTestLink>;
+export type AllureParameterApiCall = AllureApiCallBase<"parameter", RawTestParameter>;
+export type AllureFlakyApiCall = AllureApiCallBase<"flaky", boolean>;
+export type AllureMutedApiCall = AllureApiCallBase<"muted", boolean>;
+export type AllureKnownApiCall = AllureApiCallBase<"known", boolean>;
+export type AllureApiCall = AllureNameApiCall | AllureDescriptionApiCall | AllurePreconditionApiCall | AllureExpectedResultApiCall | AllureLabelApiCall | AllureLinkApiCall | AllureParameterApiCall | AllureFlakyApiCall | AllureMutedApiCall | AllureKnownApiCall;
+export type LabelsInputData = {
+    hostName: string | undefined;
+    projectName: string | undefined;
+    bundle: string | undefined;
+    suites: readonly string[];
+    className: string | undefined;
+    functionName: string | undefined;
+    tags: readonly string[];
+};

package/dist/xcresult/model.js

@@ -0,0 +1 @@
+export {};

package/dist/xcresult/utils.d.ts

@@ -0,0 +1,43 @@
+import type { RawStep, RawTestLabel, RawTestResult, RawTestStatus, RawTestStepResult } from "@allurereport/reader-api";
+import type { Unknown } from "../validation.js";
+import type { AllureApiCall, LabelsInputData, TargetDescriptor, TestRunArgs, TestRunCoordinates, TestRunLookup, TestRunSelector } from "./model.js";
+export declare const MS_IN_S = 1000;
+export declare const ALLURE_API_ACTIVITY_PREFIX = "allure.";
+export declare const statusPriorities: Map<RawTestStatus, number>;
+export declare const utiToMediaType: Record<string, string>;
+export declare const getMediaTypeByUti: (uti: string | undefined) => string | undefined;
+export declare const prependTitle: (title: string, text: string, spaces: number) => string;
+export declare const getWorstStatusWithDetails: (failureSteps: readonly RawTestStepResult[]) => Pick<RawTestStepResult, "status" | "message" | "trace">;
+export declare const countExpectedFailures: (failureSteps: readonly RawTestStepResult[]) => number;
+export declare const resolveFailureMessage: (firstFailureMessage: string | undefined, failuresCount: number, expectedFailuresCount: number) => string | undefined;
+export declare const getAggregatedFailureMessage: (message: string | undefined, failures: number, expected: number) => string;
+export declare const DEFAULT_BUNDLE_NAME = "The test bundle name is not defined";
+export declare const DEFAULT_SUITE_ID = "__unknown__";
+export declare const DEFAULT_SUITE_NAME = "The test suite name is not defined";
+export declare const DEFAULT_TEST_NAME = "The test name is not defined";
+export declare const DEFAULT_STEP_NAME = "The test name is not defined";
+export declare const DEFAULT_ATTACHMENT_NAME = "Attachment";
+export declare const DEFAULT_EXPECTED_FAILURE_REASON = "Expected failure";
+export declare const SURROGATE_DEVICE_ID: `${string}-${string}-${string}-${string}-${string}`;
+export declare const SURROGATE_TEST_PLAN_ID: `${string}-${string}-${string}-${string}-${string}`;
+export declare const SURROGATE_ARGS_ID: `${string}-${string}-${string}-${string}-${string}`;
+export declare const getArgsKeyByValues: (values: readonly (string | undefined)[]) => string;
+export declare const getArgsKey: (args: TestRunArgs) => string;
+export declare const createTestRunLookup: <T>(entries: readonly (readonly [TestRunCoordinates, T])[]) => TestRunLookup<T>;
+export declare const lookupTestAttempts: <T>(lookup: TestRunLookup<T>, { args, device, testPlan }: TestRunSelector) => T[] | undefined;
+export declare const lookupTestAttempt: <Data>(lookup: TestRunLookup<Data>, selector: TestRunSelector) => Data | undefined;
+export declare const lookupNextTestAttempt: <Data>(lookup: TestRunLookup<Data>, selector: TestRunSelector, pred: (data: Data) => boolean) => Data | undefined;
+export declare const groupBy: <T, K>(values: readonly T[], keyFn: (v: T) => K) => Map<K, T[]>;
+export declare const mappedGroupBy: <T, K, G>(values: readonly T[], keyFn: (v: T) => K, groupMapFn: (group: T[]) => G) => Map<K, G>;
+export declare const getTargetDetails: ({ architecture, model, platform, osVersion }?: TargetDescriptor) => string | undefined;
+export declare const compareChronologically: ({ start: startA, stop: stopA }: RawStep, { start: startB, stop: stopB }: RawStep) => number;
+export declare const toSortedSteps: <T extends RawStep>(...stepArrays: readonly (readonly T[])[]) => T[];
+export declare const secondsToMilliseconds: (seconds: Unknown<number>) => number | undefined;
+export declare const parseAsAllureApiActivity: (title: string | undefined) => AllureApiCall | undefined;
+export declare const splitApiCallAndValue: (text: string) => {
+    apiCall: string;
+    value: string;
+};
+export declare const applyApiCalls: (testResult: RawTestResult, apiCalls: readonly AllureApiCall[]) => void;
+export declare const createTestLabels: ({ hostName, projectName, bundle, suites, className, functionName, tags, }: LabelsInputData) => RawTestLabel[];
+export declare const getDefaultAttachmentName: (index: number, length: number) => string;

package/dist/xcresult/utils.js

@@ -0,0 +1,378 @@
+import { randomUUID } from "node:crypto";
+import { isDefined, isNumber } from "../validation.js";
+export const MS_IN_S = 1000;
+export const ALLURE_API_ACTIVITY_PREFIX = "allure.";
+export const statusPriorities = new Map([
+    ["failed", 0],
+    ["broken", 1],
+    ["unknown", 2],
+    ["skipped", 3],
+    ["passed", 4],
+]);
+export const utiToMediaType = {
+    "public.plain-text": "text/plain",
+    "public.utf8-plain-text": "text/plain",
+    "public.utf16-external-plain-text": "text/plain",
+    "public.utf16-plain-text": "text/plain",
+    "public.rtf": "text/rtf",
+    "public.html": "text/html",
+    "public.xml": "text/xml",
+    "public.source-code": "text/plain",
+    "public.c-source": "text/plain",
+    "public.objective-c-source": "text/plain",
+    "public.c-plus-plus-source": "text/plain",
+    "public.objective-c-plus-​plus-source": "text/plain",
+    "public.c-header": "text/plain",
+    "public.c-plus-plus-header": "text/plain",
+    "com.sun.java-source": "text/plain",
+    "public.script": "text/plain",
+    "public.assembly-source": "text/plain",
+    "com.apple.rez-source": "text/plain",
+    "public.mig-source": "text/plain",
+    "com.apple.symbol-export": "text/plain",
+    "com.netscape.javascript-​source": "text/plain",
+    "public.shell-script": "text/plain",
+    "public.csh-script": "text/plain",
+    "public.perl-script": "text/plain",
+    "public.python-script": "text/plain",
+    "public.ruby-script": "text/plain",
+    "public.php-script": "text/plain",
+    "com.sun.java-web-start": "text/plain",
+    "com.apple.applescript.text": "text/plain",
+    "com.microsoft.windows-​executable": "application/x-msdownload",
+    "com.microsoft.windows-​dynamic-link-library": "application/x-msdownload",
+    "com.sun.java-archive": "application/java-archive",
+    "com.apple.quartz-​composer-composition": "application/x-quartzcomposer",
+    "org.gnu.gnu-tar-archive": "application/x-gtar",
+    "public.tar-archive": "application/x-tar",
+    "org.gnu.gnu-zip-archive": "application/gzip",
+    "org.gnu.gnu-zip-tar-archive": "application/gzip",
+    "com.apple.binhex-archive": "application/mac-binhex40",
+    "com.apple.macbinary-​archive": "application/x-macbinary",
+    "public.heic": "image/heic",
+    "public.heif": "image/heif",
+    "public.jpeg": "image/jpeg",
+    "public.jpeg-2000": "image/jp2",
+    "public.tiff": "image/tiff",
+    "com.apple.pict": "image/x-pict",
+    "public.png": "image/png",
+    "public.xbitmap-image": "image/x-quicktime",
+    "com.apple.quicktime-image": "image/x-quicktime",
+    "com.apple.quicktime-movie": "video/quicktime",
+    "public.avi": "video/x-msvideo",
+    "public.mpeg": "video/mpeg",
+    "public.mpeg-4": "video/mp4",
+    "public.3gpp": "video/3gpp",
+    "public.3gpp2": "video/3gpp2",
+    "public.mp3": "audio/mpeg",
+    "public.mpeg-4-audio": "audio/mp4",
+    "public.ulaw-audio": "audio/basic",
+    "public.aifc-audio": "audio/x-aiff",
+    "public.aiff-audio": "audio/x-aiff",
+    "com.pkware.zip-archive": "application/zip",
+    "com.adobe.pdf": "application/pdf",
+    "com.adobe.photoshop-image": "image/vnd.adobe.photoshop",
+    "com.compuserve.gif": "image/gif",
+    "com.microsoft.bmp": "image/bmp",
+    "com.microsoft.ico": "image/vnd.microsoft.icon",
+    "com.microsoft.word.doc": "application/msword",
+    "com.microsoft.excel.xls": "application/vnd.ms-excel",
+    "com.microsoft.powerpoint.ppt": "application/vnd.ms-powerpoint",
+    "com.microsoft.waveform-audio": "audio/x-wav",
+    "com.microsoft.advanced-systems-format": "video/x-ms-asf",
+    "com.microsoft.windows-media-wm": "video/x-ms-wm",
+    "com.microsoft.windows-media-wmv": "video/x-ms-wmv",
+    "com.microsoft.windows-media-wmp": "video/x-ms-wmp",
+    "com.microsoft.windows-media-wma": "video/x-ms-wma",
+    "com.microsoft.advanced-stream-redirector": "video/x-ms-asx",
+    "com.microsoft.windows-media-wmx": "video/x-ms-wmx",
+    "com.microsoft.windows-media-wvx": "video/x-ms-wvx",
+    "com.microsoft.windows-media-wax": "video/x-ms-wax",
+    "com.truevision.tga-image": "image/x-tga",
+    "com.sgi.sgi-image": "image/x-sgi",
+    "com.kodak.flashpix.image": "image/vnd.fpx",
+    "com.real.realmedia": "application/vnd.rn-realmedia",
+    "com.real.realaudio": "audio/vnd.rn-realaudio",
+    "com.real.smil": "application/smil",
+    "com.allume.stuffit-archive": "application/x-stuffit",
+};
+export const getMediaTypeByUti = (uti) => (uti ? utiToMediaType[uti] : undefined);
+export const prependTitle = (title, text, spaces) => [title, ...text.split("\n").map((l) => `${" ".repeat(spaces)}${l}`)].join("\n");
+export const getWorstStatusWithDetails = (failureSteps) => {
+    const sortedFailureSteps = [...failureSteps];
+    sortedFailureSteps.sort(({ status: statusA }, { status: statusB }) => statusPriorities.get(statusA ?? "unknown") - statusPriorities.get(statusB ?? "unknown"));
+    if (!sortedFailureSteps.length) {
+        return {};
+    }
+    const { status, trace, message: worstStepMessage } = sortedFailureSteps[0];
+    const totalFailuresCount = failureSteps.length;
+    const expectedFailuresCount = countExpectedFailures(failureSteps);
+    const message = resolveFailureMessage(worstStepMessage, totalFailuresCount, expectedFailuresCount);
+    return { status, message, trace };
+};
+export const countExpectedFailures = (failureSteps) => failureSteps.reduce((a, { status }) => (status === "passed" ? a + 1 : a), 0);
+export const resolveFailureMessage = (firstFailureMessage, failuresCount, expectedFailuresCount) => {
+    switch (failuresCount) {
+        case 0:
+            return undefined;
+        case 1:
+            return firstFailureMessage;
+        default:
+            return getAggregatedFailureMessage(firstFailureMessage, failuresCount, expectedFailuresCount);
+    }
+};
+export const getAggregatedFailureMessage = (message, failures, expected) => {
+    const [summary, prefix] = failures === expected
+        ? [`${failures} expected failures have occured`, "The first one is"]
+        : expected === 0
+            ? [`${failures} failures have occured`, "The first one is"]
+            : [`${failures} failures have occured (${expected} expected)`, "The first unexpected one is"];
+    return message ? prependTitle(`${summary}. ${prefix}:`, message, 2) : summary;
+};
+export const DEFAULT_BUNDLE_NAME = "The test bundle name is not defined";
+export const DEFAULT_SUITE_ID = "__unknown__";
+export const DEFAULT_SUITE_NAME = "The test suite name is not defined";
+export const DEFAULT_TEST_NAME = "The test name is not defined";
+export const DEFAULT_STEP_NAME = "The test name is not defined";
+export const DEFAULT_ATTACHMENT_NAME = "Attachment";
+export const DEFAULT_EXPECTED_FAILURE_REASON = "Expected failure";
+export const SURROGATE_DEVICE_ID = randomUUID();
+export const SURROGATE_TEST_PLAN_ID = randomUUID();
+export const SURROGATE_ARGS_ID = randomUUID();
+export const getArgsKeyByValues = (values) => values.map(String).join(",");
+export const getArgsKey = (args) => getArgsKeyByValues(args.map((arg) => arg?.value));
+export const createTestRunLookup = (entries) => mappedGroupBy(entries, ([{ device }]) => device ?? SURROGATE_DEVICE_ID, (deviceRuns) => mappedGroupBy(deviceRuns, ([{ testPlan }]) => testPlan ?? SURROGATE_TEST_PLAN_ID, (configRuns) => mappedGroupBy(configRuns, ([{ args }]) => (args && args.length ? getArgsKey(args) : SURROGATE_ARGS_ID), (argRuns) => {
+    argRuns.sort(([{ attempt: attemptA }], [{ attempt: attemptB }]) => (attemptA ?? 0) - (attemptB ?? 0));
+    return argRuns.map(([, data]) => data);
+})));
+export const lookupTestAttempts = (lookup, { args, device, testPlan }) => lookup
+    .get(device ?? SURROGATE_DEVICE_ID)
+    ?.get(testPlan ?? SURROGATE_TEST_PLAN_ID)
+    ?.get(args ? getArgsKeyByValues(args) : SURROGATE_ARGS_ID);
+export const lookupTestAttempt = (lookup, selector) => {
+    const attempts = lookupTestAttempts(lookup, selector);
+    const { attempt = 0 } = selector;
+    return attempts?.[attempt];
+};
+export const lookupNextTestAttempt = (lookup, selector, pred) => {
+    const attempts = lookupTestAttempts(lookup, selector);
+    return attempts?.find(pred);
+};
+export const groupBy = (values, keyFn) => values.reduce((m, v) => {
+    const key = keyFn(v);
+    if (!m.get(key)?.push(v)) {
+        m.set(key, [v]);
+    }
+    return m;
+}, new Map());
+export const mappedGroupBy = (values, keyFn, groupMapFn) => {
+    const result = new Map();
+    for (const [k, g] of groupBy(values, keyFn)) {
+        result.set(k, groupMapFn(g));
+    }
+    return result;
+};
+export const getTargetDetails = ({ architecture, model, platform, osVersion } = {}) => {
+    const osPart = platform ? (osVersion ? `${platform} ${osVersion}` : platform) : undefined;
+    return [model, architecture, osPart].filter(isDefined).join(", ") || undefined;
+};
+export const compareChronologically = ({ start: startA, stop: stopA }, { start: startB, stop: stopB }) => (startA ?? 0) - (startB ?? 0) || (stopA ?? 0) - (stopB ?? 0);
+export const toSortedSteps = (...stepArrays) => {
+    const allSteps = stepArrays.reduce((result, steps) => {
+        result.push(...steps);
+        return result;
+    }, []);
+    allSteps.sort(compareChronologically);
+    return allSteps;
+};
+export const secondsToMilliseconds = (seconds) => isNumber(seconds) ? Math.round(MS_IN_S * seconds) : undefined;
+export const parseAsAllureApiActivity = (title) => {
+    if (isPotentialAllureApiActivity(title)) {
+        const maybeApiCall = title.slice(ALLURE_API_ACTIVITY_PREFIX.length);
+        const { apiCall, value } = splitApiCallAndValue(maybeApiCall);
+        switch (apiCall) {
+            case "id":
+                return { type: "label", value: { name: "ALLURE_ID", value } };
+            case "name":
+                return { type: "name", value };
+            case "description":
+                return { type: "description", value };
+            case "precondition":
+                return { type: "precondition", value };
+            case "expectedResult":
+                return { type: "expectedResult", value };
+            case "flaky":
+                return { type: "flaky", value: parseBooleanApiArg(value) };
+            case "muted":
+                return { type: "muted", value: parseBooleanApiArg(value) };
+            case "known":
+                return { type: "known", value: parseBooleanApiArg(value) };
+            default:
+                return parseComplexAllureApiCall(apiCall, value);
+        }
+    }
+};
+export const splitApiCallAndValue = (text) => {
+    const apiValueSeparatorIndex = indexOfAny(text, ":", "=");
+    return apiValueSeparatorIndex === -1
+        ? { apiCall: text, value: "" }
+        : { apiCall: text.slice(0, apiValueSeparatorIndex).trim(), value: text.slice(apiValueSeparatorIndex + 1) };
+};
+export const applyApiCalls = (testResult, apiCalls) => {
+    const groupedApiCalls = mappedGroupBy(apiCalls, (v) => v.type, (g) => g.map(({ value }) => value));
+    for (const [type, values] of groupedApiCalls) {
+        applyApiCallGroup(testResult, type, values);
+    }
+};
+const applyApiCallGroup = (testResult, type, values) => {
+    switch (type) {
+        case "name":
+            testResult.name = values.at(-1);
+            break;
+        case "flaky":
+            testResult.flaky = values.at(-1);
+            break;
+        case "muted":
+            testResult.muted = values.at(-1);
+            break;
+        case "known":
+            testResult.known = values.at(-1);
+            break;
+        case "description":
+            testResult.description = mergeMarkdownBlocks(testResult.description, ...values);
+            break;
+        case "precondition":
+            testResult.precondition = mergeMarkdownBlocks(testResult.precondition, ...values);
+            break;
+        case "expectedResult":
+            testResult.expectedResult = mergeMarkdownBlocks(testResult.expectedResult, ...values);
+            break;
+        case "label":
+            testResult.labels = [...(testResult.labels ?? []), ...values];
+            break;
+        case "link":
+            testResult.links = [...(testResult.links ?? []), ...values];
+            break;
+        case "parameter":
+            testResult.parameters = [...(testResult.parameters ?? []), ...values];
+            break;
+    }
+};
+export const createTestLabels = ({ hostName, projectName, bundle, suites, className, functionName, tags, }) => {
+    const labels = [];
+    if (hostName) {
+        labels.push({ name: "host", value: hostName });
+    }
+    const packageName = [projectName, bundle].filter(isDefined).join(".");
+    if (packageName) {
+        labels.push({ name: "package", value: packageName });
+    }
+    if (className) {
+        labels.push({ name: "testClass", value: className });
+    }
+    if (functionName) {
+        labels.push({ name: "testMethod", value: functionName });
+    }
+    if (bundle) {
+        labels.push({ name: "parentSuite", value: bundle });
+    }
+    const [suite, ...subSuites] = suites;
+    if (suite) {
+        labels.push({ name: "suite", value: suite });
+    }
+    const subSuite = subSuites.join(" > ");
+    if (subSuite) {
+        labels.push({ name: "subSuite", value: subSuite });
+    }
+    labels.push(...tags.map((value) => ({ name: "tag", value })));
+    return labels;
+};
+export const getDefaultAttachmentName = (index, length) => {
+    return length > 1 ? `${DEFAULT_ATTACHMENT_NAME} ${index + 1}` : DEFAULT_ATTACHMENT_NAME;
+};
+const mergeMarkdownBlocks = (...blocks) => blocks.filter(isDefined).reduce((a, b) => `${a}\n\n${b}`);
+const isPotentialAllureApiActivity = (title) => isDefined(title) && title.startsWith(ALLURE_API_ACTIVITY_PREFIX);
+const parseComplexAllureApiCall = (apiCall, value) => {
+    const { apiFn, primaryOption, secondaryOptions } = splitApiFnAndOptions(apiCall);
+    switch (apiFn) {
+        case "label":
+            return primaryOption ? parseAllureLabelApiCall(primaryOption, value) : undefined;
+        case "link":
+            return parseAllureLinkApiCall(primaryOption, secondaryOptions, value);
+        case "issue":
+            return parseAllureLinkApiCall(primaryOption, ["issue"], value);
+        case "tms":
+            return parseAllureLinkApiCall(primaryOption, ["tms"], value);
+        case "parameter":
+            return primaryOption ? parseAllureParameterApiCall(primaryOption, secondaryOptions, value) : undefined;
+    }
+};
+const splitApiFnAndOptions = (apiCall) => {
+    const apiFnEnd = apiCall.indexOf(".");
+    if (apiFnEnd === -1) {
+        const { primaryOption: apiFn, secondaryOptions } = parseAllureApiCallOptions(apiCall);
+        return { apiFn, primaryOption: undefined, secondaryOptions };
+    }
+    return {
+        apiFn: apiCall.slice(0, apiFnEnd),
+        ...parseAllureApiCallOptions(apiCall.slice(apiFnEnd + 1)),
+    };
+};
+const parseAllureLabelApiCall = (name, value) => name ? { type: "label", value: { name, value } } : undefined;
+const parseAllureLinkApiCall = (name, [type], url) => {
+    return { type: "link", value: { name, type, url } };
+};
+const parseAllureParameterApiCall = (name, options, value) => {
+    const parameter = { name, value };
+    options.forEach((option) => {
+        switch (option.toLowerCase()) {
+            case "hidden":
+                parameter.hidden = true;
+                break;
+            case "excluded":
+                parameter.excluded = true;
+                break;
+            case "masked":
+                parameter.masked = true;
+                break;
+        }
+    });
+    return { type: "parameter", value: parameter };
+};
+const parseAllureApiCallOptions = (options) => {
+    const primaryEnd = options.indexOf("[");
+    if (primaryEnd !== -1) {
+        const primaryOption = decodeURIComponentSafe(options.slice(0, primaryEnd));
+        if (options.indexOf("]") === options.length - 1) {
+            return {
+                primaryOption,
+                secondaryOptions: options
+                    .slice(primaryEnd + 1, -1)
+                    .split(",")
+                    .map((v) => decodeURIComponentSafe(v.trim())),
+            };
+        }
+        return { primaryOption, secondaryOptions: [] };
+    }
+    return { primaryOption: decodeURIComponentSafe(options), secondaryOptions: [] };
+};
+const indexOfAny = (input, ...searchStrings) => {
+    const indices = searchStrings.map((search) => input.indexOf(search)).filter((i) => i !== -1);
+    switch (indices.length) {
+        case 0:
+            return -1;
+        case 1:
+            return indices[0];
+        default:
+            return Math.min(...indices);
+    }
+};
+const parseBooleanApiArg = (value) => !value || value.toLowerCase() === "true";
+const decodeURIComponentSafe = (value) => {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+};

package/dist/xcresult/xcresulttool/cli.d.ts

@@ -0,0 +1,10 @@
+import type { XcActivities, XcTestDetails, XcTests } from "./xcModel.js";
+export declare const xcrunJson: <T>(utilityName: string, ...args: readonly string[]) => Promise<import("../../validation.js").Unknown<T>>;
+export declare const xcrunBinary: (utilityName: string, ...args: readonly string[]) => Promise<Buffer | undefined>;
+export declare const xcresulttool: <T>(...args: readonly string[]) => Promise<import("../../validation.js").Unknown<T>>;
+export declare const xcresulttoolBinary: (...args: readonly string[]) => Promise<Buffer | undefined>;
+export declare const version: () => Promise<string>;
+export declare const getTests: (xcResultPath: string) => Promise<import("../../validation.js").Unknown<XcTests>>;
+export declare const getTestDetails: (xcResultPath: string, testId: string) => Promise<import("../../validation.js").Unknown<XcTestDetails>>;
+export declare const getTestActivities: (xcResultPath: string, testId: string) => Promise<import("../../validation.js").Unknown<XcActivities>>;
+export declare const exportAttachments: (xcResultPath: string, outputPath: string) => Promise<void>;

package/dist/xcresult/xcresulttool/cli.js

@@ -0,0 +1,46 @@
+import console from "node:console";
+import { invokeCliTool, invokeJsonCliTool, invokeStdoutCliTool, invokeTextStdoutCliTool } from "../../toolRunner.js";
+export const xcrunJson = async (utilityName, ...args) => {
+    try {
+        return await invokeJsonCliTool("xcrun", [utilityName, ...args], { timeout: 1000 });
+    }
+    catch (e) {
+        console.error(e);
+    }
+};
+export const xcrunBinary = async (utilityName, ...args) => {
+    try {
+        const chunks = [];
+        for await (const chunk of invokeStdoutCliTool("xcrun", [utilityName, ...args], { timeout: 60000 })) {
+            chunks.push(chunk);
+        }
+        return Buffer.concat(chunks);
+    }
+    catch (e) {
+        console.error(e);
+    }
+};
+export const xcresulttool = async (...args) => await xcrunJson("xcresulttool", ...args);
+export const xcresulttoolBinary = async (...args) => await xcrunBinary("xcresulttool", ...args);
+export const version = async () => {
+    const stdout = invokeTextStdoutCliTool("xcrun", ["xcresulttool", "version"], { timeout: 1000 });
+    const lines = [];
+    for await (const line of stdout) {
+        lines.push(line);
+    }
+    return lines.join("\n");
+};
+export const getTests = async (xcResultPath) => await xcresulttool("get", "test-results", "tests", "--path", xcResultPath);
+export const getTestDetails = async (xcResultPath, testId) => await xcresulttool("get", "test-results", "test-details", "--test-id", testId, "--path", xcResultPath);
+export const getTestActivities = async (xcResultPath, testId) => await xcresulttool("get", "test-results", "activities", "--test-id", testId, "--path", xcResultPath);
+export const exportAttachments = async (xcResultPath, outputPath) => {
+    await invokeCliTool("xcrun", [
+        "xcresulttool",
+        "export",
+        "attachments",
+        "--path",
+        xcResultPath,
+        "--output-path",
+        outputPath,
+    ]);
+};

package/dist/xcresult/xcresulttool/index.d.ts

@@ -0,0 +1,7 @@
+import type { ResultFile } from "@allurereport/plugin-api";
+import type { RawTestResult } from "@allurereport/reader-api";
+import { XcresultParser } from "./model.js";
+export default class NewApiParser extends XcresultParser {
+    #private;
+    parse(): AsyncGenerator<ResultFile | RawTestResult, void, unknown>;
+}