@allurereport/reader 3.0.0-beta.3

package/README.md

@@ -0,0 +1,25 @@
+# Reader
+
+[<img src="https://allurereport.org/public/img/allure-report.svg" height="85px" alt="Allure Report logo" align="right" />](https://allurereport.org "Allure Report")
+
+- Learn more about Allure Report at https://allurereport.org
+- 📚 [Documentation](https://allurereport.org/docs/) – discover official documentation for Allure Report
+- ❓ [Questions and Support](https://github.com/orgs/allure-framework/discussions/categories/questions-support) – get help from the team and community
+- 📢 [Official announcements](https://github.com/orgs/allure-framework/discussions/categories/announcements) – be in touch with the latest updates
+- 💬 [General Discussion ](https://github.com/orgs/allure-framework/discussions/categories/general-discussion) – engage in casual conversations, share insights and ideas with the community
+
+---
+
+## Overview
+
+Set of Allure Reader implementations which allow to read different files formats as Allure Results files.
+
+## Install
+
+Use your favorite package manager to install the package:
+
+```shell
+npm add @allurereport/reader
+yarn add @allurereport/reader
+pnpm add @allurereport/reader
+```

package/dist/allure1/index.d.ts

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

package/dist/allure1/index.js

@@ -0,0 +1,143 @@
+import { XMLParser } from "fast-xml-parser";
+import { cleanBadXmlCharacters, ensureInt, ensureString, isStringAnyRecord, isStringAnyRecordArray, } from "../xml-utils.js";
+const arrayTags = new Set([
+    "test-suite.test-cases.test-case",
+    "test-suite.test-cases.test-case.steps.step",
+    "test-suite.test-cases.test-case.attachments.attachment",
+    "test-suite.test-cases.test-case.labels",
+]);
+const xmlParser = new XMLParser({
+    parseTagValue: false,
+    ignoreAttributes: false,
+    attributeNamePrefix: "",
+    removeNSPrefix: true,
+    allowBooleanAttributes: true,
+    isArray: (tagName, jPath) => arrayTags.has(jPath),
+});
+const readerId = "allure1";
+export const allure1 = {
+    async read(visitor, data) {
+        if (data.getOriginalFileName().endsWith("-testsuite.xml")) {
+            try {
+                const asBuffer = await data.asBuffer();
+                if (!asBuffer) {
+                    return false;
+                }
+                const content = cleanBadXmlCharacters(asBuffer).toString("utf-8");
+                const parsed = xmlParser.parse(content);
+                return await parseRootElement(visitor, parsed);
+            }
+            catch (e) {
+                console.error("error parsing", data.getOriginalFileName(), e);
+                return false;
+            }
+        }
+        return false;
+    },
+    readerId: () => readerId,
+};
+const parseRootElement = async (visitor, xml) => {
+    const { "test-suite": testSuite } = xml;
+    if (!isStringAnyRecord(testSuite)) {
+        return false;
+    }
+    return await parseTestSuite(visitor, testSuite);
+};
+const parseTestSuite = async (visitor, testSuite) => {
+    const { name: testSuiteName, "test-cases": testCases } = testSuite;
+    if (!isStringAnyRecord(testCases)) {
+        return false;
+    }
+    const { "test-case": testCase } = testCases;
+    if (!isStringAnyRecordArray(testCase)) {
+        return false;
+    }
+    for (const tc of testCase) {
+        await parseTestCase(visitor, { name: ensureString(testSuiteName) }, tc);
+    }
+    return true;
+};
+const parseTestCase = async (visitor, testSuite, testCase) => {
+    const { name: nameElement, status: statusElement, failure: failureElement, parameters: parametersElement, steps: stepsElement, start: startElement, stop: stopElement, } = testCase;
+    const name = ensureString(nameElement);
+    const status = convertStatus(ensureString(statusElement));
+    const { start, stop, duration } = parseTime(startElement, stopElement);
+    const { message, trace } = parseFailure(failureElement);
+    const parameters = parseParameters(parametersElement);
+    const steps = parseSteps(stepsElement);
+    await visitor.visitTestResult({ name, status, start, stop, duration, message, trace, parameters, steps }, { readerId });
+};
+const parseFailure = (element) => {
+    if (!isStringAnyRecord(element)) {
+        return {};
+    }
+    const { message, "stack-trace": trace } = element;
+    return { message: ensureString(message), trace: ensureString(trace) };
+};
+const parseTime = (startElement, stopElement) => {
+    const start = ensureInt(startElement);
+    const stop = ensureInt(stopElement);
+    const duration = stop !== undefined && start !== undefined ? Math.max(0, stop - start) : undefined;
+    return { start, stop, duration };
+};
+const parseSteps = (element) => {
+    if (!isStringAnyRecord(element)) {
+        return undefined;
+    }
+    const { step: stepElement } = element;
+    if (!isStringAnyRecordArray(stepElement)) {
+        return undefined;
+    }
+    return stepElement.map((step) => {
+        const { name, title, status, start: startElement, stop: stopElement, steps: stepsElement } = step;
+        const { start, stop, duration } = parseTime(startElement, stopElement);
+        const steps = parseSteps(stepsElement);
+        return {
+            name: ensureString(title, ensureString(name)),
+            status: convertStatus(ensureString(status)),
+            start,
+            stop,
+            duration,
+            steps,
+            type: "step",
+        };
+    });
+};
+const parseParameters = (element) => {
+    if (!isStringAnyRecord(element)) {
+        return undefined;
+    }
+    const { parameter } = element;
+    if (!isStringAnyRecordArray(parameter)) {
+        return undefined;
+    }
+    return parameter
+        .filter((p) => {
+        const { kind } = p;
+        if (!kind) {
+            return true;
+        }
+        const kindString = ensureString(kind);
+        return kindString?.toLowerCase() === "argument";
+    })
+        .map((p) => {
+        const { name, value } = p;
+        return { name: ensureString(name), value: ensureString(value) };
+    });
+};
+const convertStatus = (status) => {
+    switch (status?.toLowerCase() ?? "unknown") {
+        case "failed":
+            return "failed";
+        case "broken":
+            return "broken";
+        case "passed":
+            return "passed";
+        case "skipped":
+        case "canceled":
+        case "pending":
+            return "skipped";
+        default:
+            return "unknown";
+    }
+};

package/dist/allure2/index.d.ts

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

package/dist/allure2/index.js

@@ -0,0 +1,305 @@
+import { notNull } from "@allurereport/core-api";
+import { XMLParser } from "fast-xml-parser";
+import { randomUUID } from "node:crypto";
+import { parseProperties } from "../properties.js";
+import { cleanBadXmlCharacters, ensureBoolean, ensureInt, ensureString, isStringAnyRecord, isStringAnyRecordArray, } from "../xml-utils.js";
+import { ParameterMode } from "./model.js";
+const arrayTags = new Set(["environment.parameter"]);
+const xmlParser = new XMLParser({
+    parseTagValue: false,
+    ignoreAttributes: false,
+    attributeNamePrefix: "",
+    removeNSPrefix: true,
+    allowBooleanAttributes: true,
+    isArray: (tagName, jPath) => arrayTags.has(jPath),
+});
+const readerId = "allure2";
+export const allure2 = {
+    async read(visitor, data) {
+        if (data.getOriginalFileName().match(/.*-attachment(\..+)?/)) {
+            await visitor.visitAttachmentFile(data, { readerId });
+            return true;
+        }
+        if (data.getOriginalFileName().endsWith("-result.json")) {
+            try {
+                const parsed = await data.asJson();
+                if (parsed && isStringAnyRecord(parsed)) {
+                    await processTestResult(visitor, parsed, data.getOriginalFileName());
+                }
+                return true;
+            }
+            catch (e) {
+                console.error("error parsing", data.getOriginalFileName(), e);
+                return false;
+            }
+        }
+        if (data.getOriginalFileName().endsWith("-container.json")) {
+            const parsed = await data.asJson();
+            if (parsed) {
+                await processTestResultContainer(visitor, parsed);
+            }
+            return true;
+        }
+        if (data.getOriginalFileName() === "executor.json") {
+            try {
+                const parsed = await data.asJson();
+                if (parsed && isStringAnyRecord(parsed)) {
+                    await processExecutor(visitor, parsed);
+                }
+                return true;
+            }
+            catch (e) {
+                console.error("error parsing", data.getOriginalFileName(), e);
+                return false;
+            }
+        }
+        if (data.getOriginalFileName() === "categories.json") {
+            try {
+                const parsed = await data.asJson();
+                if (parsed && isStringAnyRecordArray(parsed)) {
+                    await processCategories(visitor, parsed);
+                }
+                return true;
+            }
+            catch (e) {
+                console.error("error parsing", data.getOriginalFileName(), e);
+                return false;
+            }
+        }
+        if (data.getOriginalFileName() === "environment.properties") {
+            try {
+                const raw = await data.asUtf8String();
+                if (raw) {
+                    const parsed = parseProperties(raw);
+                    if (parsed && isStringAnyRecord(parsed)) {
+                        await processEnvironment(visitor, parsed);
+                    }
+                }
+                return true;
+            }
+            catch (e) {
+                console.error("error parsing", data.getOriginalFileName(), e);
+                return false;
+            }
+        }
+        if (data.getOriginalFileName() === "environment.xml") {
+            try {
+                const asBuffer = await data.asBuffer();
+                if (!asBuffer) {
+                    return false;
+                }
+                const content = cleanBadXmlCharacters(asBuffer).toString("utf-8");
+                const parsed = xmlParser.parse(content);
+                if (isStringAnyRecord(parsed)) {
+                    await processEnvironmentXml(visitor, parsed);
+                }
+                return true;
+            }
+            catch (e) {
+                console.error("error parsing", data.getOriginalFileName(), e);
+                return false;
+            }
+        }
+        return false;
+    },
+    readerId: () => readerId,
+};
+const processTestResult = async (visitor, result, originalFileName) => {
+    const dest = {
+        uuid: ensureString(result.uuid),
+        fullName: ensureString(result.fullName),
+        name: ensureString(result.name),
+        testId: ensureString(result.testCaseId),
+        historyId: ensureString(result.historyId),
+        start: ensureInt(result.start),
+        stop: ensureInt(result.stop),
+        description: ensureString(result.description),
+        descriptionHtml: ensureString(result.descriptionHtml),
+        status: convertStatus(result.status),
+        message: ensureString(result?.statusDetails?.message),
+        trace: ensureString(result?.statusDetails?.trace),
+        flaky: ensureBoolean(result?.statusDetails?.flaky),
+        known: ensureBoolean(result?.statusDetails?.known),
+        muted: ensureBoolean(result?.statusDetails?.muted),
+        parameters: result?.parameters?.filter(notNull)?.map(convertParameter),
+        steps: [
+            ...(result?.steps?.filter(notNull)?.map(convertStep) ?? []),
+            ...(result?.attachments?.filter(notNull)?.map(convertAttachment) ?? []),
+        ],
+        links: result?.links?.filter(notNull)?.map(convertLink),
+        labels: result.labels?.filter(notNull)?.map(convertLabel),
+    };
+    await visitor.visitTestResult(dest, { readerId, metadata: { originalFileName } });
+};
+const processExecutor = async (visitor, result) => {
+    await visitor.visitMetadata({
+        allure2_executor: {
+            name: ensureString(result.name),
+            type: ensureString(result.type),
+            url: ensureString(result.url),
+            buildOrder: ensureInt(result.buildOrder),
+            buildName: ensureString(result.buildName),
+            buildUrl: ensureString(result.buildUrl),
+            reportName: ensureString(result.reportName),
+            reportUrl: ensureString(result.reportUrl),
+        },
+    }, { readerId });
+};
+const processCategories = async (visitor, result) => {
+    const data = result.map((value) => ({
+        name: ensureString(value.name),
+        description: ensureString(value.description),
+        descriptionHtml: ensureString(value.descriptionHtml),
+        messageRegex: ensureString(value.messageRegex),
+        traceRegex: ensureString(value.traceRegex),
+        matchedStatuses: Array.isArray(value.matchedStatuses)
+            ? value.matchedStatuses
+                .map((v) => ensureString(v))
+                .filter(notNull)
+                .map((v) => v)
+            : [],
+        flaky: ensureBoolean(value.flaky),
+    }));
+    await visitor.visitMetadata({
+        allure2_categories: data,
+    }, { readerId });
+};
+const processEnvironmentXml = async (visitor, result) => {
+    const { environment } = result;
+    if (!isStringAnyRecord(environment)) {
+        return;
+    }
+    const { parameter: parameters } = environment;
+    if (!isStringAnyRecordArray(parameters)) {
+        return;
+    }
+    const data = [];
+    parameters.forEach((param) => {
+        const { key, value } = param;
+        const stringKey = ensureString(key);
+        const stringValue = ensureString(value);
+        if (stringKey && stringValue) {
+            data.push({ name: stringKey, values: [stringValue] });
+        }
+    });
+    await visitor.visitMetadata({
+        allure_environment: data,
+    }, {
+        readerId,
+    });
+};
+const processEnvironment = async (visitor, result) => {
+    const data = Object.keys(result).map((key) => {
+        const rawValue = result[key];
+        const value = typeof rawValue === "string" ? rawValue : JSON.stringify(rawValue);
+        return {
+            name: key,
+            values: [value],
+        };
+    });
+    await visitor.visitMetadata({
+        allure_environment: data,
+    }, {
+        readerId,
+    });
+};
+async function processFixtures(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);
+        await processFixtures(visitor, result.afters, "after", result.children);
+    }
+};
+const convertStatus = (status) => {
+    switch ((status ?? "unknown").toLowerCase()) {
+        case "failed":
+            return "failed";
+        case "broken":
+            return "broken";
+        case "passed":
+            return "passed";
+        case "skipped":
+            return "skipped";
+        default:
+            return "unknown";
+    }
+};
+const convertFixture = (type, children, fixture) => {
+    return {
+        uuid: randomUUID(),
+        testResults: children,
+        type,
+        name: fixture.name,
+        start: ensureInt(fixture.start),
+        stop: ensureInt(fixture.stop),
+        status: convertStatus(fixture.status),
+        message: ensureString(fixture?.statusDetails?.message),
+        trace: ensureString(fixture?.statusDetails?.trace),
+        steps: [
+            ...(fixture?.steps?.filter(notNull)?.map(convertStep) ?? []),
+            ...(fixture?.attachments?.filter(notNull)?.map(convertAttachment) ?? []),
+        ],
+    };
+};
+const convertStep = (step) => {
+    const steps = step?.steps ?? [];
+    const attachments = step?.attachments ?? [];
+    if (steps.length === 0 && attachments.length === 1 && step.name === attachments[0].name) {
+        return {
+            ...convertAttachment(attachments[0]),
+            start: step.start,
+            stop: step.stop,
+        };
+    }
+    return {
+        name: ensureString(step.name),
+        parameters: step?.parameters?.filter(notNull)?.map(convertParameter),
+        status: convertStatus(step.status),
+        message: ensureString(step?.statusDetails?.message),
+        trace: ensureString(step?.statusDetails?.trace),
+        steps: [
+            ...(steps.filter(notNull)?.map(convertStep) ?? []),
+            ...(attachments.filter(notNull)?.map(convertAttachment) ?? []),
+        ],
+        start: ensureInt(step.start),
+        stop: ensureInt(step.stop),
+        type: "step",
+    };
+};
+const convertParameter = ({ mode, name, value, excluded }) => {
+    return {
+        name: ensureString(name),
+        value: ensureString(value),
+        excluded: ensureBoolean(excluded),
+        hidden: mode === ParameterMode.HIDDEN,
+        masked: mode === ParameterMode.MASKED,
+    };
+};
+const convertAttachment = ({ name, type, source }) => {
+    return {
+        name: ensureString(name),
+        contentType: ensureString(type),
+        originalFileName: ensureString(source),
+        type: "attachment",
+    };
+};
+const convertLabel = ({ name, value }) => {
+    return {
+        name: ensureString(name),
+        value: ensureString(value),
+    };
+};
+const convertLink = ({ name, url, type }) => {
+    return {
+        name: ensureString(name),
+        url: ensureString(url),
+        type: ensureString(type),
+    };
+};

package/dist/allure2/model.d.ts

@@ -0,0 +1,76 @@
+export interface Attachment {
+    name?: string;
+    type?: string;
+    source?: string;
+}
+export declare enum Status {
+    FAILED = "failed",
+    BROKEN = "broken",
+    PASSED = "passed",
+    SKIPPED = "skipped"
+}
+export declare enum Stage {
+    SCHEDULED = "scheduled",
+    RUNNING = "running",
+    FINISHED = "finished",
+    PENDING = "pending",
+    INTERRUPTED = "interrupted"
+}
+export declare enum ParameterMode {
+    HIDDEN = "hidden",
+    MASKED = "masked",
+    DEFAULT = "default"
+}
+export interface Label {
+    name?: string;
+    value?: string;
+}
+export interface Link {
+    name?: string;
+    url?: string;
+    type?: string;
+}
+export interface Parameter {
+    name?: string;
+    value?: string;
+    excluded?: boolean;
+    mode?: ParameterMode;
+}
+export interface StatusDetails {
+    message?: string;
+    trace?: string;
+    known?: boolean;
+    muted?: boolean;
+    flaky?: boolean;
+}
+interface ExecutableItem {
+    name?: string;
+    status?: Status;
+    statusDetails?: StatusDetails;
+    stage?: Stage;
+    description?: string;
+    descriptionHtml?: string;
+    steps?: StepResult[];
+    attachments?: Attachment[];
+    parameters?: Parameter[];
+    start?: number;
+    stop?: number;
+}
+export type FixtureResult = ExecutableItem;
+export type StepResult = ExecutableItem;
+export interface TestResult extends ExecutableItem {
+    uuid?: string;
+    historyId?: string;
+    fullName?: string;
+    testCaseId?: string;
+    labels?: Label[];
+    links?: Link[];
+}
+export interface TestResultContainer {
+    uuid?: string;
+    name?: string;
+    children?: string[];
+    befores?: FixtureResult[];
+    afters?: FixtureResult[];
+}
+export {};

package/dist/allure2/model.js

@@ -0,0 +1,21 @@
+export var Status;
+(function (Status) {
+    Status["FAILED"] = "failed";
+    Status["BROKEN"] = "broken";
+    Status["PASSED"] = "passed";
+    Status["SKIPPED"] = "skipped";
+})(Status || (Status = {}));
+export var Stage;
+(function (Stage) {
+    Stage["SCHEDULED"] = "scheduled";
+    Stage["RUNNING"] = "running";
+    Stage["FINISHED"] = "finished";
+    Stage["PENDING"] = "pending";
+    Stage["INTERRUPTED"] = "interrupted";
+})(Stage || (Stage = {}));
+export var ParameterMode;
+(function (ParameterMode) {
+    ParameterMode["HIDDEN"] = "hidden";
+    ParameterMode["MASKED"] = "masked";
+    ParameterMode["DEFAULT"] = "default";
+})(ParameterMode || (ParameterMode = {}));

package/dist/attachments/index.d.ts

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

package/dist/attachments/index.js

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

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/junitxml/index.d.ts

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

package/dist/junitxml/index.js

@@ -0,0 +1,100 @@
+import { XMLParser } from "fast-xml-parser";
+import * as console from "node:console";
+import { ensureString, isEmptyElement, isStringAnyRecord, isStringAnyRecordArray } from "../xml-utils.js";
+const arrayTags = new Set(["testsuite.testcase", "testsuites.testsuite", "testsuites.testsuite.testcase"]);
+const xmlParser = new XMLParser({
+    parseTagValue: false,
+    ignoreAttributes: false,
+    attributeNamePrefix: "",
+    removeNSPrefix: true,
+    allowBooleanAttributes: true,
+    isArray: (tagName, jPath) => arrayTags.has(jPath),
+});
+const readerId = "junit";
+export const junitXml = {
+    async read(visitor, data) {
+        if (data.getOriginalFileName().endsWith(".xml")) {
+            try {
+                const content = await data.asUtf8String();
+                if (!content) {
+                    return false;
+                }
+                const parsed = xmlParser.parse(content);
+                return await parseRootElement(visitor, parsed);
+            }
+            catch (e) {
+                console.error("error parsing", data.getOriginalFileName(), e);
+                return false;
+            }
+        }
+        return false;
+    },
+    readerId: () => readerId,
+};
+const parseRootElement = async (visitor, xml) => {
+    const { testsuite: testSuite } = xml;
+    if (isEmptyElement(testSuite)) {
+        return true;
+    }
+    if (testSuite === undefined) {
+        const { testsuites: testSuites } = xml;
+        if (isEmptyElement(testSuites)) {
+            return true;
+        }
+        if (!isStringAnyRecord(testSuites)) {
+            return false;
+        }
+        const { testsuite: testSuitesArray } = testSuites;
+        if (isEmptyElement(testSuitesArray)) {
+            return true;
+        }
+        if (!isStringAnyRecordArray(testSuitesArray)) {
+            return false;
+        }
+        for (const testSuitesArrayElement of testSuitesArray) {
+            await parseTestSuite(visitor, testSuitesArrayElement);
+        }
+        return true;
+    }
+    if (!isStringAnyRecord(testSuite)) {
+        return false;
+    }
+    await parseTestSuite(visitor, testSuite);
+    return true;
+};
+const parseTestSuite = async (visitor, testSuite) => {
+    const { name, testcase } = testSuite;
+    if (!isStringAnyRecordArray(testcase)) {
+        return;
+    }
+    for (const testcaseElement of testcase) {
+        await parseTestCase(visitor, { name: ensureString(name) }, testcaseElement);
+    }
+};
+const parseTestCase = async (visitor, suite, testCase) => {
+    const { name, classname, time, failure, skipped } = testCase;
+    const { status, message, trace } = getStatus(failure, skipped);
+    await visitor.visitTestResult({
+        name: ensureString(name),
+        status,
+        message,
+        trace,
+    }, { readerId });
+};
+const getStatus = (failure, skipped) => {
+    if (isEmptyElement(failure)) {
+        return { status: "failed" };
+    }
+    if (isStringAnyRecord(failure)) {
+        const { message, "#text": trace } = failure;
+        return { status: "failed", message: ensureString(message), trace: ensureString(trace) };
+    }
+    if (isEmptyElement(skipped)) {
+        return { status: "skipped" };
+    }
+    if (isStringAnyRecord(skipped)) {
+        const { message, "#text": trace } = skipped;
+        return { status: "skipped", message: ensureString(message), trace: ensureString(trace) };
+    }
+    return { status: "passed" };
+};

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,292 @@
+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 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":
+        case "\f":
+        case " ":
+            return true;
+    }
+    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 "=":
+        case ":":
+            return true;
+    }
+    return false;
+};
+const isComment = (char) => {
+    switch (char) {
+        case "#":
+        case "!":
+            return true;
+    }
+    return false;
+};

package/dist/xml-utils.d.ts

@@ -0,0 +1,8 @@
+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;
+export declare const cleanBadXmlCharacters: (input: Buffer) => Buffer;

package/dist/xml-utils.js

@@ -0,0 +1,46 @@
+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;
+    }
+    if (Array.isArray(obj)) {
+        return false;
+    }
+    return Object.getOwnPropertySymbols(obj).length <= 0;
+};
+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;
+    cDataCharacter || (cDataCharacter = c >= 55296 && c < 57344);
+    cDataCharacter || (cDataCharacter = c == 65534 || c == 65535);
+    return cDataCharacter;
+};
+export const cleanBadXmlCharacters = (input) => {
+    for (let i = 0; i < input.length; i++) {
+        if (isBadXmlCharacter(input[i])) {
+            input[i] = 32;
+        }
+    }
+    return input;
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@allurereport/reader",
+  "version": "3.0.0-beta.3",
+  "description": "Collection of utilities which helps to process different kind of test results as Allure Results",
+  "keywords": [
+    "allure",
+    "testing"
+  ],
+  "repository": "https://github.com/allure-framework/allure3",
+  "license": "Apache-2.0",
+  "author": "Qameta Software",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "run clean && tsc --project ./tsconfig.json",
+    "clean": "rimraf ./dist",
+    "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",
+    "fast-xml-parser": "^4.5.0"
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2.6.1",
+    "@types/eslint": "^8.56.11",
+    "@types/node": "^20.17.9",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "@vitest/runner": "^2.1.8",
+    "allure-js-commons": "^3.0.7",
+    "allure-vitest": "^3.0.7",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-jsdoc": "^50.0.0",
+    "eslint-plugin-n": "^17.10.1",
+    "eslint-plugin-no-null": "^1.0.2",
+    "eslint-plugin-prefer-arrow": "^1.2.3",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
+  }
+}