@allurereport/reader-api 3.0.0-beta.8 → 3.0.0

package/dist/index.d.ts

@@ -3,3 +3,5 @@ export type * from "./reader.js";
 export * from "./resultFile.js";
 export { detectContentType } from "./detect.js";
 export { extension, lookupContentType } from "./utils.js";
+export * from "./validation.js";
+export * from "./toolRunner.js";

package/dist/index.js

@@ -1,3 +1,5 @@
 export * from "./resultFile.js";
 export { detectContentType } from "./detect.js";
 export { extension, lookupContentType } from "./utils.js";
+export * from "./validation.js";
+export * from "./toolRunner.js";

package/dist/model.d.ts

@@ -13,7 +13,10 @@ export interface RawFixtureResult {
     status?: RawTestStatus;
     message?: string;
     trace?: string;
+    expected?: string;
+    actual?: string;
     steps?: RawStep[];
+    titlePath?: string[];
 }
 export interface RawTestResult {
     uuid?: string;
@@ -34,6 +37,8 @@ export interface RawTestResult {
     duration?: number;
     message?: string;
     trace?: string;
+    expected?: string;
+    actual?: string;
     flaky?: boolean;
     muted?: boolean;
     known?: boolean;
@@ -43,6 +48,7 @@ export interface RawTestResult {
     steps?: RawStep[];
     labels?: RawTestLabel[];
     links?: RawTestLink[];
+    titlePath?: string[];
 }
 export interface RawTestLabel {
     name?: string;
@@ -66,6 +72,8 @@ export interface RawTestStepResult {
     status?: RawTestStatus;
     message?: string;
     trace?: string;
+    actual?: string;
+    expected?: string;
     start?: number;
     stop?: number;
     duration?: number;

package/dist/resultFile.js

@@ -70,7 +70,7 @@ export class BufferResultFile extends BaseResultFile {
         this.buffer = buffer;
     }
     getContent() {
-        return ReadStream.from(this.buffer, { encoding: "utf8" });
+        return ReadStream.from(this.buffer);
     }
     readMagicHeader() {
         return this.buffer.subarray(0, magicHeaderLength);

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 collectCliToolStdoutText: (executable: string, args: readonly string[], options?: ProcessRunOptions) => Promise<string>;
+export declare const invokeJsonCliTool: <T>(tool: string, args: readonly string[], options?: ProcessRunOptions) => Promise<Unknown<T>>;
+export {};

package/dist/toolRunner.js

@@ -0,0 +1,145 @@
+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,
+        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 collectCliToolStdoutText = async (executable, args, options = {}) => {
+    const { encoding = "utf-8", ...rest } = options;
+    const chunks = [];
+    for await (const chunk of invokeStdoutCliTool(executable, args, rest)) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString(encoding);
+};
+export const invokeJsonCliTool = async (tool, args, options = {}) => {
+    const text = await collectCliToolStdoutText(tool, args, options);
+    return JSON.parse(text);
+};

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/reader-api",
-  "version": "3.0.0-beta.8",
+  "version": "3.0.0",
   "description": "Allure Reader API",
   "keywords": [
     "allure",
@@ -27,8 +27,8 @@
     "test": "rimraf ./out && vitest run"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.0.0-beta.8",
-    "@allurereport/plugin-api": "3.0.0-beta.8",
+    "@allurereport/core-api": "3.0.0",
+    "@allurereport/plugin-api": "3.0.0",
     "mime-types": "^2.1.35"
   },
   "devDependencies": {
@@ -38,8 +38,8 @@
     "@types/node": "^20.17.9",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
-    "@vitest/runner": "^2.1.8",
-    "allure-vitest": "^3.0.9",
+    "@vitest/runner": "^2.1.9",
+    "allure-vitest": "^3.3.3",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.29.1",
@@ -51,6 +51,6 @@
     "ts-node": "^10.9.2",
     "tslib": "^2.7.0",
     "typescript": "^5.6.3",
-    "vitest": "^2.1.8"
+    "vitest": "^2.1.9"
   }
 }