@allurereport/reader 3.0.0-beta.10

package/dist/model.d.ts

@@ -0,0 +1,20 @@
+export interface ExecutorInfo {
+    name: string;
+    type: string;
+    url: string;
+    buildOrder: number;
+    buildName: string;
+    buildUrl: string;
+    reportName: string;
+    reportUrl: string;
+}
+export interface Category {
+    name: string;
+    description?: string;
+    descriptionHtml?: string;
+    messageRegex?: string;
+    traceRegex?: string;
+    matchedStatuses: string[];
+    flaky?: boolean;
+}
+export type EnvironmentInfo = Record<string, string | undefined>;

package/dist/model.js

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

package/dist/properties.d.ts

@@ -0,0 +1 @@
+export declare const parseProperties: (input: string) => Record<string, string | undefined>;

package/dist/properties.js

@@ -0,0 +1,229 @@
+export const parseProperties = (input) => {
+    if (!input) {
+        return {};
+    }
+    const result = {};
+    let escape = false;
+    let skipSpace = true;
+    let isCommentLine = false;
+    let newLine = true;
+    let multiLine = false;
+    let isKey = true;
+    let key = "";
+    let value = "";
+    let unicode;
+    let unicodeRemaining = 0;
+    let escapingUnicode = false;
+    let keySpace = false;
+    let sep = false;
+    const line = () => {
+        if (key || value || sep) {
+            result[key] = value;
+            key = "";
+            value = "";
+            sep = false;
+        }
+    };
+    const decodeString = (output, char) => {
+        if (escapingUnicode && unicodeRemaining) {
+            unicode = (unicode << 4) + hex(char);
+            if (--unicodeRemaining) {
+                return output;
+            }
+            escape = false;
+            escapingUnicode = false;
+            return output + String.fromCharCode(unicode);
+        }
+        if (char === "u") {
+            unicode = 0;
+            escapingUnicode = true;
+            unicodeRemaining = 4;
+            return output;
+        }
+        escape = false;
+        switch (char) {
+            case "t":
+                return `${output}\t`;
+            case "r":
+                return `${output}\r`;
+            case "n":
+                return `${output}\n`;
+            case "f":
+                return `${output}\f`;
+        }
+        return output + char;
+    };
+    for (const char of input) {
+        if (char === "\r") {
+            continue;
+        }
+        if (isCommentLine) {
+            if (char === "\n") {
+                isCommentLine = false;
+                newLine = true;
+                skipSpace = true;
+            }
+            continue;
+        }
+        if (skipSpace) {
+            if (isWhitespace(char)) {
+                continue;
+            }
+            if (!multiLine && char === "\n") {
+                isKey = true;
+                keySpace = false;
+                newLine = true;
+                line();
+                continue;
+            }
+            skipSpace = false;
+            multiLine = false;
+        }
+        if (newLine) {
+            newLine = false;
+            if (isComment(char)) {
+                isCommentLine = true;
+                continue;
+            }
+        }
+        if (char !== "\n") {
+            if (!escape && isKey && isSeparator(char)) {
+                sep = true;
+                isKey = false;
+                keySpace = false;
+                skipSpace = true;
+                continue;
+            }
+            if (char === "\\") {
+                if (escape) {
+                    if (escapingUnicode) {
+                        continue;
+                    }
+                    if (keySpace) {
+                        keySpace = false;
+                        isKey = false;
+                    }
+                    if (isKey) {
+                        key += "\\";
+                    }
+                    else {
+                        value += "\\";
+                    }
+                }
+                escape = !escape;
+            }
+            else {
+                if (keySpace) {
+                    keySpace = false;
+                    isKey = false;
+                }
+                if (isKey) {
+                    if (escape) {
+                        key = decodeString(key, char);
+                    }
+                    else {
+                        if (isWhitespace(char)) {
+                            keySpace = true;
+                            skipSpace = true;
+                            continue;
+                        }
+                        key += char;
+                    }
+                }
+                else {
+                    if (escape) {
+                        value = decodeString(value, char);
+                    }
+                    else {
+                        value += char;
+                    }
+                }
+            }
+        }
+        else {
+            if (escape) {
+                if (!escapingUnicode) {
+                    escape = false;
+                }
+                skipSpace = true;
+                multiLine = true;
+            }
+            else {
+                newLine = true;
+                skipSpace = true;
+                isKey = true;
+                line();
+            }
+        }
+    }
+    line();
+    return result;
+};
+const hex = (char) => {
+    switch (char) {
+        case "0":
+            return 0;
+        case "1":
+            return 1;
+        case "2":
+            return 2;
+        case "3":
+            return 3;
+        case "4":
+            return 4;
+        case "5":
+            return 5;
+        case "6":
+            return 6;
+        case "7":
+            return 7;
+        case "8":
+            return 8;
+        case "9":
+            return 9;
+        case "a":
+        case "A":
+            return 10;
+        case "b":
+        case "B":
+            return 11;
+        case "c":
+        case "C":
+            return 12;
+        case "d":
+        case "D":
+            return 13;
+        case "e":
+        case "E":
+            return 14;
+        case "f":
+        case "F":
+            return 15;
+    }
+    throw new Error(`Non-hex char ${char}`);
+};
+const isWhitespace = (char) => {
+    switch (char) {
+        case "\t":
+        case "\f":
+        case " ":
+            return true;
+    }
+    return false;
+};
+const isSeparator = (char) => {
+    switch (char) {
+        case "=":
+        case ":":
+            return true;
+    }
+    return false;
+};
+const isComment = (char) => {
+    switch (char) {
+        case "#":
+        case "!":
+            return true;
+    }
+    return false;
+};

package/dist/toolRunner.d.ts

@@ -0,0 +1,17 @@
+import type { Unknown } from "./validation.js";
+export type ProcessRunOptions = {
+    exitCode?: number | ((code: number) => boolean);
+    encoding?: BufferEncoding;
+    stderrEncoding?: BufferEncoding;
+    timeout?: number;
+    timeoutSignal?: NodeJS.Signals;
+    ignoreStderr?: boolean;
+};
+export declare const invokeCliTool: (executable: string, args: readonly string[], { timeout, timeoutSignal, ignoreStderr, encoding, exitCode: expectedExitCode }?: ProcessRunOptions) => Promise<void>;
+type ResolveCliOutput<T> = T extends {
+    encoding: BufferEncoding;
+} ? string : Buffer;
+export declare const invokeStdoutCliTool: <T extends ProcessRunOptions | undefined>(executable: string, args: readonly string[], options?: T) => AsyncGenerator<ResolveCliOutput<T>, void, unknown>;
+export declare const invokeTextStdoutCliTool: (executable: string, args: readonly string[], options?: ProcessRunOptions) => AsyncGenerator<string, void, unknown>;
+export declare const invokeJsonCliTool: <T>(tool: string, args: readonly string[], options?: ProcessRunOptions) => Promise<Unknown<T>>;
+export {};

package/dist/toolRunner.js

@@ -0,0 +1,143 @@
+import { spawn } from "node:child_process";
+const LINE_SPLIT_PATTERN = /\r\n|\r|\n/;
+export const invokeCliTool = async (executable, args, { timeout, timeoutSignal, ignoreStderr, encoding, exitCode: expectedExitCode = 0 } = {}) => {
+    const toolProcess = spawn(executable, args, {
+        stdio: ["ignore", "ignore", ignoreStderr ? "ignore" : "pipe"],
+        shell: false,
+        timeout: timeout,
+        killSignal: timeoutSignal,
+    });
+    const stderr = [];
+    if (!ignoreStderr) {
+        toolProcess.stderr?.setEncoding(encoding ?? "utf-8").on("data", (chunk) => stderr.push(String(chunk)));
+    }
+    let onSuccess;
+    let onError;
+    const resultPromise = new Promise((resolve, reject) => {
+        onSuccess = resolve;
+        onError = reject;
+    });
+    toolProcess.on("exit", (code, signal) => {
+        if (signal) {
+            onError(new Error(timeout && toolProcess.killed
+                ? `${executable} was terminated by timeout (${timeout} ms)`
+                : `${executable} was terminated with ${signal}`));
+            return;
+        }
+        if (typeof expectedExitCode === "number" ? code !== expectedExitCode : expectedExitCode(code)) {
+            onError(new Error(`${executable} finished with an unexpected exit code ${code}`));
+            return;
+        }
+        onSuccess();
+    });
+    return await resultPromise;
+};
+export const invokeStdoutCliTool = async function* (executable, args, options) {
+    const { timeout, timeoutSignal, encoding, stderrEncoding, exitCode: expectedExitCode = 0, ignoreStderr, } = options ?? {};
+    const emitTextChunk = (chunk) => {
+        const lines = (unfinishedLineBuffer + chunk).split(LINE_SPLIT_PATTERN);
+        if (lines.length) {
+            unfinishedLineBuffer = lines.at(-1);
+            stdoutChunks.push(...lines.slice(0, -1));
+            maybeContinueConsumption();
+        }
+    };
+    const emitFinalTextChunk = () => {
+        if (unfinishedLineBuffer) {
+            stdoutChunks.push(unfinishedLineBuffer);
+            unfinishedLineBuffer = "";
+            maybeContinueConsumption();
+        }
+    };
+    const emitBinaryChunk = (chunk) => {
+        stdoutChunks.push(chunk);
+        maybeContinueConsumption();
+    };
+    const emitError = (message) => {
+        if (stderrChunks.length) {
+            message = `${message}\n\nStandard error:\n\n${stderrChunks.join("")}`;
+        }
+        bufferedError = new Error(message);
+        maybeContinueConsumption();
+    };
+    const checkExitCode = (code) => {
+        if (typeof expectedExitCode === "number") {
+            return code === expectedExitCode;
+        }
+        return expectedExitCode(code);
+    };
+    const maybeContinueConsumption = () => {
+        if (continueConsumption) {
+            const continueConsumptionLocal = continueConsumption;
+            continueConsumption = undefined;
+            continueConsumptionLocal();
+        }
+    };
+    const stdoutChunks = [];
+    let unfinishedLineBuffer = "";
+    let done = false;
+    let bufferedError;
+    const stderrChunks = [];
+    let continueConsumption;
+    const toolProcess = spawn(executable, args, {
+        stdio: ["ignore", "pipe", ignoreStderr ? "ignore" : "pipe"],
+        shell: false,
+        timeout,
+        killSignal: timeoutSignal,
+    });
+    const { stdout, stderr } = toolProcess;
+    if (stdout) {
+        if (encoding) {
+            stdout.setEncoding(encoding).on("data", emitTextChunk);
+        }
+        else {
+            stdout.on("data", emitBinaryChunk);
+        }
+    }
+    if (stderr) {
+        stderr.setEncoding(stderrEncoding ?? encoding ?? "utf-8").on("data", stderrChunks.push.bind(stderrChunks));
+    }
+    toolProcess.on("exit", (code, signal) => {
+        emitFinalTextChunk();
+        done = true;
+        if (bufferedError) {
+            return;
+        }
+        if (signal) {
+            emitError(timeout && toolProcess.killed
+                ? `${executable} was terminated by timeout (${timeout} ms)`
+                : `${executable} was terminated with ${signal}`);
+            return;
+        }
+        if (!checkExitCode(code)) {
+            emitError(`${executable} finished with an unexpected exit code ${code}`);
+            return;
+        }
+        continueConsumption?.();
+    });
+    while (true) {
+        if (stdoutChunks.length) {
+            yield* stdoutChunks;
+            stdoutChunks.splice(0);
+        }
+        if (bufferedError) {
+            throw bufferedError;
+        }
+        if (done) {
+            return;
+        }
+        await new Promise((resolve) => {
+            continueConsumption = resolve;
+        });
+    }
+};
+export const invokeTextStdoutCliTool = async function* (executable, args, options = {}) {
+    yield* invokeStdoutCliTool(executable, args, { encoding: "utf-8", ...options });
+};
+export const invokeJsonCliTool = async (tool, args, options = {}) => {
+    const lines = [];
+    for await (const line of invokeTextStdoutCliTool(tool, args, options)) {
+        lines.push(line);
+    }
+    return JSON.parse(lines.join(""));
+};

package/dist/utils.d.ts

@@ -0,0 +1,13 @@
+export declare const isBoolean: (value: unknown) => value is boolean;
+export declare const isString: (value: unknown) => value is string;
+export declare const isArray: <T = unknown>(value: unknown) => value is T[];
+export declare const isNonNullObject: <T extends object = object>(value: unknown) => value is T;
+export declare function ensureBoolean(value: unknown): boolean | undefined;
+export declare function ensureBoolean(value: unknown, fallback: boolean): boolean;
+export declare const ensureInt: (obj: unknown) => number | undefined;
+export declare function ensureString(value: unknown): string | undefined;
+export declare function ensureString(value: unknown, fallback: string): string;
+export declare function ensureArray<T = unknown>(value: unknown): T[] | undefined;
+export declare function ensureArray<T = unknown>(value: unknown, fallback: T[]): T[];
+export declare function ensureObject<T extends object = object>(value: unknown): T | undefined;
+export declare function ensureObject<T extends object = object>(value: unknown, fallback: T): T;

package/dist/utils.js

@@ -0,0 +1,27 @@
+export const isBoolean = (value) => typeof value === "boolean";
+export const isString = (value) => typeof value === "string";
+export const isArray = (value) => Array.isArray(value);
+export const isNonNullObject = (value) => typeof value === "object" && value !== null;
+export function ensureBoolean(value, fallback) {
+    return isBoolean(value) ? value : fallback;
+}
+export const ensureInt = (obj) => {
+    if (typeof obj === "number") {
+        return obj;
+    }
+    const stringValue = ensureString(obj);
+    if (!stringValue) {
+        return undefined;
+    }
+    const parsed = parseInt(stringValue, 10);
+    return isNaN(parsed) ? undefined : parsed;
+};
+export function ensureString(value, fallback) {
+    return isString(value) ? value : fallback;
+}
+export function ensureArray(value, fallback) {
+    return isArray(value) ? value : fallback;
+}
+export function ensureObject(value, fallback) {
+    return isNonNullObject(value) ? value : fallback;
+}

package/dist/validation.d.ts

@@ -0,0 +1,45 @@
+declare const unknownKey: unique symbol;
+export type Unknown<T> = typeof unknownKey | ShallowKnown<T> | undefined | null;
+export type ShallowKnown<T> = T extends object ? T extends (...v: any[]) => any ? T : {
+    [key in keyof T]: Unknown<T[key]>;
+} : T;
+export type IsSuper<SuperType, SubType> = [SubType] extends [never] ? never : [SubType] extends [SuperType] ? SuperType : never;
+export type Narrow<SuperType, SubType> = [SubType] extends [never] ? never : [SubType] extends [SuperType] ? SubType : never;
+export type ArrayElement<T> = T extends readonly (infer E)[] ? E : never;
+export type IsHomogeneousObject<T> = T extends object ? T extends readonly any[] ? never : T extends {
+    [key in keyof T]: infer U;
+} ? {
+    [key in keyof T]: U;
+} extends T ? T : never : never : never;
+export type NarrowHomogeneousObject<T, R> = T extends object ? T extends readonly any[] ? never : T extends {
+    [key in keyof T]: infer U;
+} ? {
+    [key in keyof T]: U;
+} extends T ? {
+    [key in keyof T]?: R;
+} : never : never : never;
+export type HomogeneousObjectItem<T> = T extends object ? T extends readonly any[] ? never : T extends {
+    [key in keyof T]: infer U;
+} ? {
+    [key in keyof T]: U;
+} extends T ? U : never : never : never;
+export type ConditionalUnion<CA, A, CB, B> = [CA] extends [never] ? B : [CB] extends [never] ? A : A | B;
+export declare const isDefined: <T>(value: T | undefined) => value is T;
+export declare const isString: <T>(value: Unknown<IsSuper<T, string>>) => value is ShallowKnown<Narrow<T, string>>;
+export declare const isNumber: <T>(value: Unknown<IsSuper<T, number>>) => value is ShallowKnown<Narrow<T, number>>;
+export declare const isBoolean: <T>(value: Unknown<IsSuper<T, boolean>>) => value is ShallowKnown<Narrow<T, boolean>>;
+export declare const isArray: <T>(value: Unknown<IsSuper<T, Extract<T, readonly any[]>>>) => value is ShallowKnown<Extract<Narrow<T, Extract<T, readonly any[]>>, readonly any[]>>;
+export declare const isObject: <T>(value: Unknown<IsSuper<T, Extract<Exclude<T, readonly any[]>, object>>>) => value is ShallowKnown<Narrow<T, Extract<Exclude<T, readonly any[]>, object>>>;
+export declare const isLiteral: <T, const L extends readonly any[]>(value: Unknown<IsSuper<T, L[number]>>, literals: L) => value is ShallowKnown<L[number]>;
+export declare const ensureString: <T>(value: Unknown<T>) => string | undefined;
+export declare const ensureNumber: <T>(value: Unknown<T>) => number | undefined;
+export declare const ensureBoolean: <T>(value: Unknown<T>) => boolean | undefined;
+export declare const ensureInt: <T>(value: Unknown<T>) => number | undefined;
+export declare const ensureFloat: <T>(value: Unknown<T>) => number | undefined;
+export declare const ensureArray: <T>(value: Unknown<IsSuper<T, Extract<T, readonly any[]>>>) => ShallowKnown<Extract<Narrow<T, Extract<T, readonly any[]>>, readonly any[]>> | undefined;
+export declare const ensureObject: <T>(value: Unknown<IsSuper<T, Extract<Exclude<T, readonly any[]>, object>>>) => ShallowKnown<Narrow<T, Extract<Exclude<T, readonly any[]>, object>>> | undefined;
+export declare const ensureLiteral: <T, const L extends readonly any[]>(value: Unknown<T>, literals: L) => ShallowKnown<L[number]> | undefined;
+export declare const ensureArrayWithItems: <T, R extends ShallowKnown<ArrayElement<T>>>(value: Unknown<IsSuper<T, Extract<T, ArrayElement<T>[]>>>, guard: (v: Unknown<ArrayElement<T>>) => v is R) => R[] | undefined;
+export declare const ensureObjectWithProps: <T, R extends ShallowKnown<HomogeneousObjectItem<T>>>(value: Unknown<IsSuper<T, Extract<T, IsHomogeneousObject<T>>>>, guard: (v: Unknown<HomogeneousObjectItem<T>>) => v is R) => NarrowHomogeneousObject<T, R> | undefined;
+export declare const ensureItems: <T, R extends ShallowKnown<HomogeneousObjectItem<T> | ArrayElement<T>>>(value: Unknown<IsSuper<T, Extract<T, IsHomogeneousObject<T> | ArrayElement<T>[]>>>, guard: (v: Unknown<HomogeneousObjectItem<T> | ArrayElement<T>>) => v is R) => ConditionalUnion<ArrayElement<T>, R[], IsHomogeneousObject<T>, NarrowHomogeneousObject<T, R>> | undefined;
+export {};

package/dist/validation.js

@@ -0,0 +1,51 @@
+const unknownKey = Symbol("This must be an Unknown<T>");
+export const isDefined = (value) => typeof value !== "undefined";
+export const isString = (value) => typeof value === "string";
+export const isNumber = (value) => typeof value === "number";
+export const isBoolean = (value) => typeof value === "boolean";
+export const isArray = (value) => Array.isArray(value);
+export const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+export const isLiteral = (value, literals) => literals.includes(value);
+export const ensureString = (value) => typeof value === "string" ? value : undefined;
+export const ensureNumber = (value) => typeof value === "number" ? value : undefined;
+export const ensureBoolean = (value) => typeof value === "boolean" ? value : undefined;
+export const ensureInt = (value) => {
+    if (typeof value === "number") {
+        return Math.floor(value);
+    }
+    if (typeof value === "string") {
+        const parsed = parseInt(value, 10);
+        if (!isNaN(parsed)) {
+            return parsed;
+        }
+    }
+};
+export const ensureFloat = (value) => {
+    if (typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const parsed = parseFloat(value);
+        if (!isNaN(parsed)) {
+            return parsed;
+        }
+    }
+};
+export const ensureArray = (value) => isArray(value) ? value : undefined;
+export const ensureObject = (value) => isObject(value) ? value : undefined;
+export const ensureLiteral = (value, literals) => literals.includes(value) ? value : undefined;
+export const ensureArrayWithItems = (value, guard) => ensureArray(value)?.filter(guard);
+export const ensureObjectWithProps = (value, guard) => {
+    const obj = ensureObject(value);
+    if (obj) {
+        return Object.entries(obj).reduce((a, [k, v]) => {
+            if (guard(v)) {
+                a[k] = v;
+            }
+            return a;
+        }, {});
+    }
+};
+export const ensureItems = (value, guard) => {
+    return ensureArrayWithItems(value, guard) ?? ensureObjectWithProps(value, guard);
+};

package/dist/xcresult/bundle.d.ts

@@ -0,0 +1,7 @@
+export declare const XCRESULTTOOL_MISSING_MESSAGE = "'xcresulttool' is required to parse Xcode Result bundles, but we can't access it on this machine. This tool is a part of Xcode. Please make sure Xcode is installed. Visit this page to learn more about the installation:\n\n    https://developer.apple.com/documentation/safari-developer-tools/installing-xcode-and-simulators\n\nNote that 'xcresulttool' doesn't come with Command Line Tools for Xcode. You need to install the full Xcode package to get it. If you have both installed, make sure the full installation is selected. Switch to it with xcode-select if necessary (the path to Xcode's Developer directory might be different on your machine):\n\n    sudo xcode-select -s /Applications/Xcode.app/Contents/Developer\n\nThe original error that led to this message is shown below.\n";
+export declare const IS_MAC: boolean;
+export declare const isXcResultBundle: (directory: string) => Promise<boolean>;
+export declare const checkUniformTypeIdentifier: (itemPath: string, uti: string) => Promise<boolean | undefined>;
+export declare const isMostProbablyXcResultBundle: (directory: string) => Promise<boolean>;
+export declare const followsXcResultNaming: (directory: string) => boolean;
+export declare const findBundleInfoFile: (directory: string) => Promise<string | undefined>;

package/dist/xcresult/bundle.js

@@ -0,0 +1,63 @@
+import { lstat } from "node:fs/promises";
+import { platform } from "node:os";
+import path from "node:path";
+import { invokeStdoutCliTool } from "../toolRunner.js";
+import { isDefined } from "../validation.js";
+const XCODE_INSTALL_URL = "https://developer.apple.com/documentation/safari-developer-tools/installing-xcode-and-simulators";
+const XCODE_SWITCH_COMMAND = "sudo xcode-select -s /Applications/Xcode.app/Contents/Developer";
+export const XCRESULTTOOL_MISSING_MESSAGE = `'xcresulttool' is required to parse Xcode Result bundles, but we can't \
+access it on this machine. This tool is a part of Xcode. Please make sure Xcode is installed. Visit this page to learn \
+more about the installation:
+
+    ${XCODE_INSTALL_URL}
+
+Note that 'xcresulttool' doesn't come with Command Line Tools for Xcode. You need to install the full Xcode package to \
+get it. If you have both installed, make sure the full installation is selected. Switch to it with xcode-select if \
+necessary (the path to Xcode's Developer directory might be different on your machine):
+
+    ${XCODE_SWITCH_COMMAND}
+
+The original error that led to this message is shown below.
+`;
+const bundleInfoFilePaths = new Set([
+    "Info.plist",
+    "Contents/Info.plist",
+    "Support Files/Info.plist",
+    "Resources/Info.plist",
+]);
+export const IS_MAC = platform() === "darwin";
+export const isXcResultBundle = async (directory) => {
+    const hasXcResultUti = IS_MAC
+        ? await checkUniformTypeIdentifier(directory, "com.apple.xcode.resultbundle")
+        : undefined;
+    return hasXcResultUti ?? (await isMostProbablyXcResultBundle(directory));
+};
+export const checkUniformTypeIdentifier = async (itemPath, uti) => {
+    const mdlsArgs = ["-raw", "-attr", "kMDItemContentTypeTree", itemPath];
+    const stringToSearch = `"${uti}"`;
+    try {
+        for await (const line of invokeStdoutCliTool("mdls", mdlsArgs)) {
+            if (line.indexOf(stringToSearch) !== -1) {
+                return true;
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return false;
+};
+export const isMostProbablyXcResultBundle = async (directory) => isDefined(await findBundleInfoFile(directory)) || followsXcResultNaming(directory);
+export const followsXcResultNaming = (directory) => directory.endsWith(".xcresult");
+export const findBundleInfoFile = async (directory) => {
+    for (const infoFilePath of bundleInfoFilePaths) {
+        const infoFileAbsPath = path.join(directory, infoFilePath);
+        try {
+            const stat = await lstat(infoFileAbsPath);
+            if (stat.isFile()) {
+                return infoFileAbsPath;
+            }
+        }
+        catch { }
+    }
+};

package/dist/xcresult/index.d.ts

@@ -0,0 +1,2 @@
+import type { ResultsVisitor } from "@allurereport/reader-api";
+export declare const readXcResultBundle: (visitor: ResultsVisitor, directory: string) => Promise<boolean>;