@allurereport/reader 3.0.0-beta.3 → 3.0.0-beta.4

package/dist/allure1/index.js

@@ -1,5 +1,7 @@
 import { XMLParser } from "fast-xml-parser";
-import { cleanBadXmlCharacters, ensureInt, ensureString, isStringAnyRecord, isStringAnyRecordArray, } from "../xml-utils.js";
+import * as console from "node:console";
+import { ensureInt, ensureString } from "../utils.js";
+import { cleanBadXmlCharacters, isStringAnyRecord, isStringAnyRecordArray } from "../xml-utils.js";
 const arrayTags = new Set([
     "test-suite.test-cases.test-case",
     "test-suite.test-cases.test-case.steps.step",
@@ -16,7 +18,7 @@ const xmlParser = new XMLParser({
 });
 const readerId = "allure1";
 export const allure1 = {
-    async read(visitor, data) {
+    read: async (visitor, data) => {
         if (data.getOriginalFileName().endsWith("-testsuite.xml")) {
             try {
                 const asBuffer = await data.asBuffer();
@@ -25,6 +27,9 @@ export const allure1 = {
                 }
                 const content = cleanBadXmlCharacters(asBuffer).toString("utf-8");
                 const parsed = xmlParser.parse(content);
+                if (!isStringAnyRecord(parsed)) {
+                    return false;
+                }
                 return await parseRootElement(visitor, parsed);
             }
             catch (e) {
@@ -93,7 +98,7 @@ const parseSteps = (element) => {
         const { start, stop, duration } = parseTime(startElement, stopElement);
         const steps = parseSteps(stepsElement);
         return {
-            name: ensureString(title, ensureString(name)),
+            name: ensureString(title) ?? ensureString(name),
             status: convertStatus(ensureString(status)),
             start,
             stop,

package/dist/allure2/index.js

@@ -1,8 +1,10 @@
 import { notNull } from "@allurereport/core-api";
 import { XMLParser } from "fast-xml-parser";
+import * as console from "node:console";
 import { randomUUID } from "node:crypto";
 import { parseProperties } from "../properties.js";
-import { cleanBadXmlCharacters, ensureBoolean, ensureInt, ensureString, isStringAnyRecord, isStringAnyRecordArray, } from "../xml-utils.js";
+import { ensureBoolean, ensureInt, ensureString } from "../utils.js";
+import { cleanBadXmlCharacters, isStringAnyRecord, isStringAnyRecordArray } from "../xml-utils.js";
 import { ParameterMode } from "./model.js";
 const arrayTags = new Set(["environment.parameter"]);
 const xmlParser = new XMLParser({
@@ -15,7 +17,7 @@ const xmlParser = new XMLParser({
 });
 const readerId = "allure2";
 export const allure2 = {
-    async read(visitor, data) {
+    read: async (visitor, data) => {
         if (data.getOriginalFileName().match(/.*-attachment(\..+)?/)) {
             await visitor.visitAttachmentFile(data, { readerId });
             return true;
@@ -153,10 +155,7 @@ const processCategories = async (visitor, result) => {
         messageRegex: ensureString(value.messageRegex),
         traceRegex: ensureString(value.traceRegex),
         matchedStatuses: Array.isArray(value.matchedStatuses)
-            ? value.matchedStatuses
-                .map((v) => ensureString(v))
-                .filter(notNull)
-                .map((v) => v)
+            ? value.matchedStatuses.map((v) => ensureString(v)).filter(notNull)
             : [],
         flaky: ensureBoolean(value.flaky),
     }));
@@ -203,14 +202,14 @@ const processEnvironment = async (visitor, result) => {
         readerId,
     });
 };
-async function processFixtures(visitor, fixtures, type, children) {
+const processFixtures = async (visitor, fixtures, type, children) => {
     if (fixtures) {
         for (const fixture of fixtures) {
             const dist = convertFixture(type, children, fixture);
             await visitor.visitTestFixtureResult(dist, { readerId });
         }
     }
-}
+};
 const processTestResultContainer = async (visitor, result) => {
     if (result.children && result.children.length > 0) {
         await processFixtures(visitor, result.befores, "before", result.children);

package/dist/attachments/index.d.ts

@@ -1,2 +1,2 @@
-import { ResultsReader } from "@allurereport/reader-api";
+import type { ResultsReader } from "@allurereport/reader-api";
 export declare const attachments: ResultsReader;

package/dist/attachments/index.js

@@ -1,6 +1,6 @@
 const readerId = "attachments";
 export const attachments = {
-    async read(visitor, data) {
+    read: async (visitor, data) => {
         await visitor.visitAttachmentFile(data, { readerId });
         return true;
     },

package/dist/cucumberjson/index.d.ts

@@ -0,0 +1,2 @@
+import type { ResultsReader } from "@allurereport/reader-api";
+export declare const cucumberjson: ResultsReader;

package/dist/cucumberjson/index.js

@@ -0,0 +1,285 @@
+import { BufferResultFile } from "@allurereport/reader-api";
+import { randomUUID } from "node:crypto";
+import { ensureArray, ensureInt, ensureString, isArray, isNonNullObject, isString } from "../utils.js";
+import { STEP_NAME_PLACEHOLDER, TEST_NAME_PLACEHOLDER } from "./model.js";
+const NS_IN_MS = 1000000;
+const readerId = "cucumberjson";
+const allureStepStatusPriorityOrder = {
+    failed: 0,
+    broken: 1,
+    unknown: 2,
+    skipped: 3,
+    passed: 4,
+};
+const cucumberStatusToAllureStatus = {
+    unknown: "unknown",
+    passed: "passed",
+    skipped: "skipped",
+    pending: "skipped",
+    ["undefined"]: "broken",
+    ambiguous: "broken",
+    failed: "failed",
+};
+const allureStepMessages = {
+    unknown: "The result of the step is unknown",
+    passed: "The step passed",
+    skipped: "The step was skipped because the previous step hadn't passed",
+    pending: "The step signalled pending during execution",
+    ["undefined"]: "The step didn't match any definition",
+    ambiguous: "The step matched more than one definition",
+    failed: "The step failed",
+};
+export const cucumberjson = {
+    read: async (visitor, data) => {
+        const originalFileName = data.getOriginalFileName();
+        try {
+            const parsed = await data.asJson();
+            if (parsed) {
+                let oneOrMoreFeaturesParsed = false;
+                for (const feature of parsed) {
+                    oneOrMoreFeaturesParsed || (oneOrMoreFeaturesParsed = await processFeature(visitor, originalFileName, feature));
+                }
+                return oneOrMoreFeaturesParsed;
+            }
+        }
+        catch (e) {
+            console.error("error parsing", originalFileName, e);
+            return false;
+        }
+        return false;
+    },
+    readerId: () => readerId,
+};
+const processFeature = async (visitor, originalFileName, feature) => {
+    if (isCucumberFeature(feature)) {
+        const preProcessedFeature = preProcessFeature(feature);
+        for (const scenario of feature.elements) {
+            await processScenario(visitor, originalFileName, preProcessedFeature, scenario);
+        }
+        return true;
+    }
+    return false;
+};
+const processScenario = async (visitor, originalFileName, feature, scenario) => {
+    const preProcessedScenario = preProcessScenario(scenario);
+    if (shouldProcessScenario(preProcessedScenario)) {
+        const preProcessedSteps = await preProcessSteps(visitor, scenario.steps ?? []);
+        await visitor.visitTestResult(mapCucumberScenarioToAllureTestResult(feature, preProcessedScenario, preProcessedSteps), {
+            readerId,
+            metadata: { originalFileName },
+        });
+    }
+};
+const shouldProcessScenario = ({ type }) => type !== "background";
+const preProcessSteps = async (visitor, steps) => {
+    const preProcessedSteps = [];
+    for (const step of steps) {
+        preProcessedSteps.push(await preProcessOneStep(visitor, step));
+    }
+    return preProcessedSteps;
+};
+const preProcessOneStep = async (visitor, step) => {
+    const { keyword, name, result } = step;
+    const { status, duration, error_message: errorMessage } = result ?? {};
+    return {
+        name: ensureString(name)?.trim(),
+        keyword: ensureString(keyword)?.trim(),
+        status: status ?? "unknown",
+        duration: ensureInt(duration),
+        errorMessage,
+        attachments: await processStepAttachments(visitor, step),
+    };
+};
+const processStepAttachments = async (visitor, step) => [
+    await processStepDocStringAttachment(visitor, step),
+    await processStepDataTableAttachment(visitor, step),
+    ...(await processStepEmbeddingAttachments(visitor, step)),
+].filter((s) => typeof s !== "undefined");
+const processStepDocStringAttachment = async (visitor, { doc_string: docString }) => {
+    if (docString) {
+        const { value, content_type: contentType } = docString;
+        if (value && value.trim()) {
+            return await visitBufferAttachment(visitor, "Description", Buffer.from(value), contentType || "text/markdown");
+        }
+    }
+};
+const processStepDataTableAttachment = async (visitor, { rows }) => {
+    if (isArray(rows)) {
+        const content = formatDataTable(rows);
+        return await visitBufferAttachment(visitor, "Data", Buffer.from(content), "text/csv");
+    }
+};
+const processStepEmbeddingAttachments = async (visitor, { embeddings }) => {
+    const attachments = [];
+    const checkedEmbeddings = ensureArray(embeddings) ?? [];
+    const getName = checkedEmbeddings.length > 1 ? (i) => `Embedding ${i}` : () => "Embedding";
+    const embeddingsWithNames = checkedEmbeddings.map((e, i) => [e, getName(i + 1)]);
+    for (const [embedding, fallbackName] of embeddingsWithNames) {
+        if (isNonNullObject(embedding)) {
+            attachments.push(await visitBufferAttachment(visitor, ensureString(embedding.name, fallbackName), Buffer.from(ensureString(embedding.data, ""), "base64"), ensureString(embedding.mime_type, "application/octet-stream")));
+        }
+    }
+    return attachments;
+};
+const visitBufferAttachment = async (visitor, name, content, contentType) => {
+    const fileName = randomUUID();
+    await visitor.visitAttachmentFile(new BufferResultFile(content, fileName), { readerId });
+    return {
+        type: "attachment",
+        contentType,
+        originalFileName: fileName,
+        name,
+    };
+};
+const formatDataTable = (rows) => {
+    return rows
+        .filter((isNonNullObject))
+        .map(formatDataTableRow)
+        .filter(isString)
+        .join("\r\n");
+};
+const formatDataTableRow = ({ cells }) => {
+    const checkedCells = ensureArray(cells);
+    return checkedCells ? checkedCells.map(formatDataTableCell).join(",") : undefined;
+};
+const formatDataTableCell = (cell) => {
+    const escapedCell = ensureString(cell, "").replaceAll(String.raw `"`, String.raw `""`);
+    return `"${escapedCell}"`;
+};
+const isCucumberFeature = ({ keyword, elements }) => typeof keyword === "string" && keyword.toLowerCase() === "feature" && Array.isArray(elements);
+const pairWithAllureSteps = (preProcessedCucumberSteps) => preProcessedCucumberSteps.map((c) => {
+    return {
+        preProcessedStep: c,
+        allureStep: createAllureStepResult(c),
+    };
+});
+const mapCucumberScenarioToAllureTestResult = (preProcessedFeature, scenario, preProcessedSteps) => {
+    const postProcessedSteps = pairWithAllureSteps(preProcessedSteps);
+    return {
+        fullName: calculateFullName(preProcessedFeature, scenario),
+        name: scenario.name ?? TEST_NAME_PLACEHOLDER,
+        description: scenario.description,
+        duration: convertDuration(calculateTestDuration(postProcessedSteps)),
+        steps: postProcessedSteps.map(({ allureStep }) => allureStep),
+        labels: calculateTestLabels(preProcessedFeature, scenario),
+        ...resolveTestResultStatusProps(postProcessedSteps),
+    };
+};
+const calculateTestLabels = ({ name: featureName, tags: featureTags }, { tags: scenarioTags }) => {
+    const labels = [];
+    if (featureName) {
+        labels.push({ name: "feature", value: featureName });
+    }
+    labels.push(...featureTags.map((value) => ({ name: "tag", value })), ...scenarioTags.map((value) => ({ name: "tag", value })));
+    return labels;
+};
+const preProcessFeature = (feature) => {
+    return {
+        id: ensureString(feature.id),
+        name: ensureString(feature.name),
+        uri: ensureString(feature.uri),
+        tags: parseTags(feature.tags),
+    };
+};
+const parseTags = (tags) => {
+    return (ensureArray(tags) ?? [])
+        .filter((isNonNullObject))
+        .map(({ name }) => name)
+        .filter(isString);
+};
+const preProcessScenario = (scenario) => {
+    return {
+        id: ensureString(scenario.id),
+        name: ensureString(scenario.name),
+        description: ensureString(scenario.description),
+        tags: parseTags(scenario.tags),
+        type: scenario.type,
+    };
+};
+const calculateFullName = ({ uri: featureUri, name: featureName, id: featureId }, { name: scenarioName, id: scenarioId }) => {
+    if (!scenarioName && !scenarioId) {
+        return randomUUID();
+    }
+    const featurePart = featureUri || featureName || featureId;
+    if (featurePart) {
+        const scenarioPart = scenarioName || scenarioId;
+        return `${featurePart}#${scenarioPart}`;
+    }
+    return scenarioId || scenarioName;
+};
+const calculateTestDuration = (cucumberAllureStepData) => cucumberAllureStepData.reduce((testDuration, { preProcessedStep: { duration } }) => typeof testDuration === "undefined" ? duration : testDuration + (duration ?? 0), undefined);
+const resolveTestResultStatusProps = (cucumberAllureSteps) => {
+    const stepsData = getCucumberAllureStepWithMaxPriorityStatus(cucumberAllureSteps);
+    return stepsData
+        ? resolveResultOfTestFromStepsData(stepsData)
+        : {
+            status: "unknown",
+            message: "Step results are missing",
+        };
+};
+const resolveResultOfTestFromStepsData = ({ preProcessedStep: { status: cucumberStatus, errorMessage }, allureStep: { name, status }, }) => ({
+    status: status ?? "unknown",
+    ...resolveTestMessageAndTrace(name, cucumberStatus, errorMessage),
+});
+const resolveTestMessageAndTrace = (allureStepName, status, errorMessage) => status !== "passed"
+    ? {
+        message: resolveTestMessage(status, allureStepName),
+        trace: errorMessage,
+    }
+    : {};
+const resolveTestMessage = (cucumberStepStatus, allureStepName) => {
+    switch (cucumberStepStatus) {
+        case "failed":
+            return `The step '${allureStepName}' failed`;
+        case "skipped":
+            return "One or more steps of the scenario were skipped";
+        case "pending":
+            return `The step '${allureStepName}' signalled pending during execution`;
+        case "undefined":
+            return `The step '${allureStepName}' didn't match any definition`;
+        case "ambiguous":
+            return `The step '${allureStepName}' matched more than one definition`;
+        case "unknown":
+        default:
+            return `The result of the step '${allureStepName}' is unknown`;
+    }
+};
+const getCucumberAllureStepWithMaxPriorityStatus = (cucumberAllureSteps) => {
+    switch (cucumberAllureSteps.length) {
+        case 0:
+            return undefined;
+        case 1:
+            return cucumberAllureSteps[0];
+        default:
+            return cucumberAllureSteps.reduce(statusPriorityReducingFn);
+    }
+};
+const statusPriorityReducingFn = (testDefiningStep, currentStep) => allureStepStatusPriorityOrder[testDefiningStep.allureStep.status] <=
+    allureStepStatusPriorityOrder[currentStep.allureStep.status]
+    ? testDefiningStep
+    : currentStep;
+const createAllureStepResult = ({ keyword, name, status, duration, errorMessage, attachments, }) => ({
+    type: "step",
+    name: getAllureStepName(keyword, name),
+    steps: attachments,
+    ...mapCucumberStepResultToStepProps(status, duration, errorMessage),
+});
+const getAllureStepName = (keyword, name) => {
+    if (!name) {
+        return keyword ? `${keyword} <${STEP_NAME_PLACEHOLDER.toLowerCase()}>` : STEP_NAME_PLACEHOLDER;
+    }
+    return keyword ? `${keyword} ${name}` : name;
+};
+const mapCucumberStepResultToStepProps = (status, duration, errorMessage) => ({
+    status: cucumberStatusToAllureStatus[status ?? "unknown"] ?? "unknown",
+    duration: convertDuration(duration),
+    ...resolveStepMessageAndTrace(status, errorMessage),
+});
+const resolveStepMessageAndTrace = (status, errorMessage) => status !== "passed" || errorMessage
+    ? {
+        message: allureStepMessages[status ?? "unknown"] ?? allureStepMessages.unknown,
+        trace: errorMessage,
+    }
+    : {};
+const convertDuration = (duration) => typeof duration !== "undefined" ? nsToMs(duration) : undefined;
+const nsToMs = (ns) => Math.round(ns / NS_IN_MS);

package/dist/cucumberjson/model.d.ts

@@ -0,0 +1,60 @@
+export declare const TEST_NAME_PLACEHOLDER = "The scenario's name is not defined";
+export declare const STEP_NAME_PLACEHOLDER = "The step's name is not defined";
+export type CucumberFeature = {
+    description: string;
+    elements: CucumberFeatureElement[];
+    id: string;
+    keyword: string;
+    line: number;
+    name: string;
+    tags?: unknown;
+    uri: string;
+};
+export type CucumberFeatureElement = {
+    after?: CucumberStep[];
+    before?: CucumberStep[];
+    description: string;
+    id?: string;
+    keyword: string;
+    line: number;
+    name: string;
+    steps?: CucumberStep[];
+    tags?: unknown;
+    type: string;
+};
+export type CucumberStep = {
+    doc_string?: CucumberDocString;
+    embeddings?: unknown;
+    keyword?: string;
+    line?: number;
+    match?: CucumberStepMatch;
+    name?: string;
+    output?: string[];
+    result: CucumberStepResult;
+    rows?: unknown;
+};
+export type CucumberDocString = {
+    content_type?: string;
+    line?: number;
+    value?: string;
+};
+export type CucumberDatatableRow = {
+    cells: unknown;
+};
+export type CucumberStepResult = {
+    duration?: number;
+    error_message?: string;
+    status: string;
+};
+export type CucumberStepMatch = {
+    location: string;
+};
+export type CucumberTag = {
+    line: number;
+    name: unknown;
+};
+export type CucumberEmbedding = {
+    data: unknown;
+    mime_type: unknown;
+    name?: unknown;
+};

package/dist/cucumberjson/model.js

@@ -0,0 +1,2 @@
+export const TEST_NAME_PLACEHOLDER = "The scenario's name is not defined";
+export const STEP_NAME_PLACEHOLDER = "The step's name is not defined";

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./allure1/index.js";
 export * from "./allure2/index.js";
+export * from "./cucumberjson/index.js";
 export * from "./junitxml/index.js";
 export * from "./attachments/index.js";
-export * from "./model.js";
+export type * from "./model.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 export * from "./allure1/index.js";
 export * from "./allure2/index.js";
+export * from "./cucumberjson/index.js";
 export * from "./junitxml/index.js";
 export * from "./attachments/index.js";
-export * from "./model.js";

package/dist/junitxml/index.js

@@ -1,6 +1,7 @@
 import { XMLParser } from "fast-xml-parser";
 import * as console from "node:console";
-import { ensureString, isEmptyElement, isStringAnyRecord, isStringAnyRecordArray } from "../xml-utils.js";
+import { ensureString } from "../utils.js";
+import { isEmptyElement, isStringAnyRecord, isStringAnyRecordArray } from "../xml-utils.js";
 const arrayTags = new Set(["testsuite.testcase", "testsuites.testsuite", "testsuites.testsuite.testcase"]);
 const xmlParser = new XMLParser({
     parseTagValue: false,
@@ -12,7 +13,7 @@ const xmlParser = new XMLParser({
 });
 const readerId = "junit";
 export const junitXml = {
-    async read(visitor, data) {
+    read: async (visitor, data) => {
         if (data.getOriginalFileName().endsWith(".xml")) {
             try {
                 const content = await data.asUtf8String();
@@ -20,6 +21,9 @@ export const junitXml = {
                     return false;
                 }
                 const parsed = xmlParser.parse(content);
+                if (!isStringAnyRecord(parsed)) {
+                    return false;
+                }
                 return await parseRootElement(visitor, parsed);
             }
             catch (e) {
@@ -72,7 +76,7 @@ const parseTestSuite = async (visitor, testSuite) => {
     }
 };
 const parseTestCase = async (visitor, suite, testCase) => {
-    const { name, classname, time, failure, skipped } = testCase;
+    const { name, failure, skipped } = testCase;
     const { status, message, trace } = getStatus(failure, skipped);
     await visitor.visitTestResult({
         name: ensureString(name),

package/dist/properties.js

@@ -202,63 +202,6 @@ const hex = (char) => {
     }
     throw new Error(`Non-hex char ${char}`);
 };
-const escapeKey = (key) => {
-    return mapcatChars(key, (char, code) => {
-        if (isSeparator(char)) {
-            return `\\${char}`;
-        }
-        return escapeCharacter(char, code, true);
-    });
-};
-const escapeValue = (value) => {
-    let escapeWhitespace = true;
-    return mapcatChars(value, (char, code) => {
-        if (!isWhitespace(char)) {
-            escapeWhitespace = false;
-        }
-        return escapeCharacter(char, code, escapeWhitespace);
-    });
-};
-const mapcatChars = (value, fn) => {
-    let result = "";
-    for (let i = 0; i < value.length; i++) {
-        const char = value[i];
-        const code = value.charCodeAt(i);
-        result += fn(char, code);
-    }
-    return result;
-};
-const escapeCharacter = (char, code, escapeWhitespace) => {
-    if (isAsciiPrintable(code)) {
-        if (char === " " && escapeWhitespace) {
-            return "\\ ";
-        }
-        else if (char === "\\") {
-            return "\\\\";
-        }
-        else {
-            return char;
-        }
-    }
-    else if (char === "\t") {
-        return "\\t";
-    }
-    else if (char === "\n") {
-        return "\\n";
-    }
-    else if (char === "\f") {
-        return "\\f";
-    }
-    else if (char === "\r") {
-        return "\\r";
-    }
-    else if (code < 160 || code >= 256) {
-        return escapeUnicode(code);
-    }
-    else {
-        return char;
-    }
-};
 const isWhitespace = (char) => {
     switch (char) {
         case "\t":
@@ -268,12 +211,6 @@ const isWhitespace = (char) => {
     }
     return false;
 };
-const isAsciiPrintable = (code) => code > 31 && code < 127;
-const escapeUnicode = (code) => {
-    const unicode = code.toString(16);
-    const prefix = "0".repeat(4 - unicode.length);
-    return `\\u${prefix}${unicode}`;
-};
 const isSeparator = (char) => {
     switch (char) {
         case "=":

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

@@ -1,7 +1,4 @@
 export declare const isEmptyElement: (obj: unknown) => obj is "";
-export declare const ensureBoolean: (obj: unknown, fallback?: boolean) => boolean | undefined;
-export declare const ensureString: (obj: unknown, fallback?: string) => string | undefined;
-export declare const ensureInt: (obj: unknown) => number | undefined;
 export declare const isStringAnyRecord: (obj: unknown) => obj is Record<string, any>;
 export declare const isStringAnyRecordArray: (obj: unknown) => obj is Record<string, any>[];
 export declare const isBadXmlCharacter: (c: number) => boolean;

package/dist/xml-utils.js

@@ -1,23 +1,6 @@
 export const isEmptyElement = (obj) => {
     return obj === "";
 };
-export const ensureBoolean = (obj, fallback) => {
-    return typeof obj === "boolean" ? obj : fallback;
-};
-export const ensureString = (obj, fallback) => {
-    return typeof obj === "string" ? obj : fallback;
-};
-export const ensureInt = (obj) => {
-    if (typeof obj === "number") {
-        return obj;
-    }
-    const stringValue = ensureString(obj);
-    if (!stringValue) {
-        return undefined;
-    }
-    const parsed = parseInt(stringValue);
-    return isNaN(parsed) ? undefined : parsed;
-};
 export const isStringAnyRecord = (obj) => {
     if (typeof obj !== "object") {
         return false;
@@ -31,9 +14,9 @@ export const isStringAnyRecordArray = (obj) => {
     return Array.isArray(obj) && obj.every((item) => isStringAnyRecord(item));
 };
 export const isBadXmlCharacter = (c) => {
-    let cDataCharacter = c < 32 && c != 9 && c != 13 && c != 10;
+    let cDataCharacter = c < 32 && c !== 9 && c !== 13 && c !== 10;
     cDataCharacter || (cDataCharacter = c >= 55296 && c < 57344);
-    cDataCharacter || (cDataCharacter = c == 65534 || c == 65535);
+    cDataCharacter || (cDataCharacter = c === 65534 || c === 65535);
     return cDataCharacter;
 };
 export const cleanBadXmlCharacters = (input) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/reader",
-  "version": "3.0.0-beta.3",
+  "version": "3.0.0-beta.4",
   "description": "Collection of utilities which helps to process different kind of test results as Allure Results",
   "keywords": [
     "allure",
@@ -21,12 +21,14 @@
   "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": "vitest run"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.0.0-beta.3",
-    "@allurereport/plugin-api": "3.0.0-beta.3",
-    "@allurereport/reader-api": "3.0.0-beta.3",
+    "@allurereport/core-api": "3.0.0-beta.4",
+    "@allurereport/plugin-api": "3.0.0-beta.4",
+    "@allurereport/reader-api": "3.0.0-beta.4",
     "fast-xml-parser": "^4.5.0"
   },
   "devDependencies": {