@allurereport/reader-api 3.0.0-beta.10

package/README.md

@@ -0,0 +1,25 @@
+# Reader API
+
+[<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
+
+The interfaces in the package describe the entities used for building Allure Readers.
+
+## Install
+
+Use your favorite package manager to install the package:
+
+```shell
+npm add @allurereport/reader-api
+yarn add @allurereport/reader-api
+pnpm add @allurereport/reader-api
+```

package/dist/detect.d.ts

@@ -0,0 +1,2 @@
+declare const detectContentType: (buffer: Uint8Array) => string | undefined;
+export { detectContentType };

package/dist/detect.js

@@ -0,0 +1,557 @@
+const rawMagics = [
+    {
+        name: "video/mp4",
+        priority: 60,
+        clause: {
+            clause: "match",
+            value: "ftypmp42",
+            type: "string",
+            offset: "4",
+        },
+        extensions: [".mp4", ".mp4v", ".mpg4"],
+    },
+    {
+        name: "video/mp4",
+        priority: 60,
+        clause: {
+            clause: "match",
+            value: "ftypmp41",
+            type: "string",
+            offset: "4",
+        },
+        extensions: [".mp4", ".mp4v", ".mpg4"],
+    },
+    {
+        name: "image/svg+xml",
+        priority: 50,
+        clause: {
+            clause: "and",
+            nested: [
+                {
+                    clause: "match",
+                    value: "<svg",
+                    type: "string",
+                    offset: "0",
+                },
+                {
+                    clause: "match",
+                    value: "http://www.w3.org/2000/svg",
+                    type: "string",
+                    offset: "5:256",
+                },
+            ],
+        },
+        extensions: [".svg", ".svgz"],
+    },
+    {
+        name: "image/png",
+        priority: 50,
+        clause: {
+            clause: "match",
+            value: "\\x89PNG\\x0d\\x0a\\x1a\\x0a",
+            type: "string",
+            offset: "0",
+        },
+        extensions: [".png"],
+    },
+    {
+        name: "application/x-gtar",
+        priority: 50,
+        clause: {
+            clause: "match",
+            value: "ustar  \\0",
+            type: "string",
+            offset: "257",
+        },
+        extensions: [".gtar"],
+    },
+    {
+        name: "application/pdf",
+        priority: 50,
+        clause: {
+            clause: "match",
+            value: "\\xef\\xbb\\xbf%PDF-",
+            type: "string",
+            offset: "0",
+        },
+        extensions: [".pdf"],
+    },
+    {
+        name: "image/gif",
+        priority: 50,
+        clause: {
+            clause: "match",
+            value: "GIF89a",
+            type: "string",
+            offset: "0",
+        },
+        extensions: [".gif"],
+    },
+    {
+        name: "image/gif",
+        priority: 50,
+        clause: {
+            clause: "match",
+            value: "GIF87a",
+            type: "string",
+            offset: "0",
+        },
+        extensions: [".gif"],
+    },
+    {
+        name: "image/bmp",
+        priority: 50,
+        clause: {
+            clause: "and",
+            nested: [
+                {
+                    clause: "match",
+                    value: "BM",
+                    type: "string",
+                    offset: "0",
+                },
+                {
+                    clause: "and",
+                    nested: [
+                        {
+                            clause: "match",
+                            value: "0x0100",
+                            type: "string",
+                            offset: "26",
+                        },
+                        {
+                            clause: "or",
+                            nested: [
+                                {
+                                    clause: "match",
+                                    value: "0x0000",
+                                    type: "string",
+                                    offset: "28",
+                                },
+                                {
+                                    clause: "match",
+                                    value: "0x0100",
+                                    type: "string",
+                                    offset: "28",
+                                },
+                                {
+                                    clause: "match",
+                                    value: "0x0400",
+                                    type: "string",
+                                    offset: "28",
+                                },
+                                {
+                                    clause: "match",
+                                    value: "0x0800",
+                                    type: "string",
+                                    offset: "28",
+                                },
+                                {
+                                    clause: "match",
+                                    value: "0x1000",
+                                    type: "string",
+                                    offset: "28",
+                                },
+                                {
+                                    clause: "match",
+                                    value: "0x1800",
+                                    type: "string",
+                                    offset: "28",
+                                },
+                                {
+                                    clause: "match",
+                                    value: "0x2000",
+                                    type: "string",
+                                    offset: "28",
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        },
+        extensions: [".bmp", ".dib"],
+    },
+    {
+        name: "application/pdf",
+        priority: 50,
+        clause: {
+            clause: "match",
+            value: "%PDF-",
+            type: "string",
+            offset: "0",
+        },
+        extensions: [".pdf"],
+    },
+    {
+        name: "image/tiff",
+        priority: 50,
+        clause: {
+            clause: "match",
+            value: "MM\\x00\\x2b",
+            type: "string",
+            offset: "0",
+        },
+        extensions: [".tiff", ".tif"],
+    },
+    {
+        name: "image/tiff",
+        priority: 50,
+        clause: {
+            clause: "match",
+            value: "MM\\x00\\x2a",
+            type: "string",
+            offset: "0",
+        },
+        extensions: [".tiff", ".tif"],
+    },
+    {
+        name: "image/tiff",
+        priority: 50,
+        clause: {
+            clause: "match",
+            value: "II\\x2a\\x00",
+            type: "string",
+            offset: "0",
+        },
+        extensions: [".tiff", ".tif"],
+    },
+    {
+        name: "application/zip",
+        priority: 50,
+        clause: {
+            clause: "match",
+            value: "PK\\x07\\x08",
+            type: "string",
+            offset: "0",
+        },
+        extensions: [".zip"],
+    },
+    {
+        name: "application/zip",
+        priority: 50,
+        clause: {
+            clause: "match",
+            value: "PK\\005\\006",
+            type: "string",
+            offset: "0",
+        },
+        extensions: [".zip"],
+    },
+    {
+        name: "application/zip",
+        priority: 50,
+        clause: {
+            clause: "match",
+            value: "PK\\003\\004",
+            type: "string",
+            offset: "0",
+        },
+        extensions: [".zip"],
+    },
+    {
+        name: "image/jpeg",
+        priority: 50,
+        clause: {
+            clause: "match",
+            value: "0xffd8ff",
+            type: "string",
+            offset: "0",
+        },
+        extensions: [".jpg", ".jpeg", ".jpe", ".jif", ".jfif", ".jfi"],
+    },
+    {
+        name: "application/gzip",
+        priority: 45,
+        clause: {
+            clause: "match",
+            value: "\\x1f\\x8b",
+            type: "string",
+            offset: "0",
+        },
+        extensions: [".gz", ".tgz", "-gz"],
+    },
+    {
+        name: "application/gzip",
+        priority: 45,
+        clause: {
+            clause: "match",
+            value: "\\037\\213",
+            type: "string",
+            offset: "0",
+        },
+        extensions: [".gz", ".tgz", "-gz"],
+    },
+    {
+        name: "application/pdf",
+        priority: 40,
+        clause: {
+            clause: "and",
+            nested: [
+                {
+                    clause: "match",
+                    value: "%%",
+                    type: "string",
+                    offset: "0:128",
+                },
+                {
+                    clause: "match",
+                    value: "%PDF-2.",
+                    type: "string",
+                    offset: "1:512",
+                },
+            ],
+        },
+        extensions: [".pdf"],
+    },
+    {
+        name: "application/pdf",
+        priority: 40,
+        clause: {
+            clause: "and",
+            nested: [
+                {
+                    clause: "match",
+                    value: "%%",
+                    type: "string",
+                    offset: "0:128",
+                },
+                {
+                    clause: "match",
+                    value: "%PDF-1.",
+                    type: "string",
+                    offset: "1:512",
+                },
+            ],
+        },
+        extensions: [".pdf"],
+    },
+    {
+        name: "application/x-tar",
+        priority: 40,
+        clause: {
+            clause: "match",
+            value: "ustar\\0",
+            type: "string",
+            offset: "257",
+        },
+        extensions: [".tar"],
+    },
+    {
+        name: "application/pdf",
+        priority: 20,
+        clause: {
+            clause: "match",
+            value: "%PDF-2.",
+            type: "string",
+            offset: "1:512",
+        },
+        extensions: [".pdf"],
+    },
+    {
+        name: "application/pdf",
+        priority: 20,
+        clause: {
+            clause: "match",
+            value: "%PDF-1.",
+            type: "string",
+            offset: "1:512",
+        },
+        extensions: [".pdf"],
+    },
+];
+const decodeString = (value, type) => {
+    if (value.startsWith("0x")) {
+        const vals = new Uint8Array((value.length - 2) / 2);
+        for (let i = 0; i < vals.length; i++) {
+            vals[i] = parseInt(value.substring(2 + i * 2, 4 + i * 2), 16);
+        }
+        return vals;
+    }
+    const decoded = [];
+    for (let i = 0; i < value.length; i++) {
+        if (value[i] === "\\") {
+            if (value[i + 1] === "\\") {
+                decoded.push(92);
+                i++;
+            }
+            else if (value[i + 1] === "x") {
+                decoded.push(parseInt(value.substring(i + 2, i + 4), 16));
+                i += 3;
+            }
+            else if (value[i + 1] === "r") {
+                decoded.push(13);
+                i++;
+            }
+            else if (value[i + 1] === "n") {
+                decoded.push(10);
+                i++;
+            }
+            else {
+                let j = i + 1;
+                while (j < i + 4 && j < value.length && /\d/.test(value[j])) {
+                    j++;
+                }
+                decoded.push(parseInt(`0${value.substring(i + 1, j)}`, 10));
+                i = j - 1;
+            }
+        }
+        else {
+            decoded.push(value.charCodeAt(i));
+        }
+    }
+    const chars = decoded;
+    let bytes;
+    if (type === "unicodeLE") {
+        bytes = new Uint8Array(chars.length * 2);
+        for (let i = 0; i < chars.length; i++) {
+            bytes[i * 2] = chars[i] & 0xff;
+            bytes[i * 2 + 1] = chars[i] >> 8;
+        }
+    }
+    else if (type === "unicodeBE") {
+        bytes = new Uint8Array(chars.length * 2);
+        for (let i = 0; i < chars.length; i++) {
+            bytes[i * 2] = chars[i] >> 8;
+            bytes[i * 2 + 1] = chars[i] & 0xff;
+        }
+    }
+    else {
+        bytes = new Uint8Array(chars.length);
+        for (let i = 0; i < bytes.length; i++) {
+            bytes[i] = chars[i];
+        }
+    }
+    return bytes;
+};
+class AndClause {
+    constructor(clauses) {
+        this.clauses = clauses;
+    }
+    eval(data) {
+        for (const clause of this.clauses) {
+            if (!clause.eval(data)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+class OrClause {
+    constructor(clauses) {
+        this.clauses = clauses;
+    }
+    eval(data) {
+        for (const clause of this.clauses) {
+            if (!clause.eval(data)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+class MagicMatchClause {
+    constructor(pattern, mask, start = 0, end = start) {
+        this.pattern = pattern;
+        this.mask = mask;
+        this.start = start;
+        this.end = end;
+        this.eval = (data) => {
+            if (data.length < this.pattern.length + this.start) {
+                return false;
+            }
+            for (let i = this.start; i <= this.end; i++) {
+                let match = true;
+                for (let j = 0; match && j < this.pattern.length; j++) {
+                    const masked = data[i + j] & this.mask[j];
+                    match = masked === this.pattern[j];
+                }
+                if (match) {
+                    return true;
+                }
+            }
+            return false;
+        };
+    }
+}
+const parseClause = (rawClause) => {
+    if (rawClause.clause === "and") {
+        return new AndClause(rawClause.nested.map((nested) => parseClause(nested)));
+    }
+    if (rawClause.clause === "or") {
+        return new OrClause(rawClause.nested.map((nested) => parseClause(nested)));
+    }
+    return createMagicMatch(rawClause.value, rawClause.mask, rawClause.offset, rawClause.type);
+};
+const parseMagics = (data) => {
+    return data.map((m) => {
+        return {
+            priority: m.priority,
+            type: m.name,
+            extensions: m.extensions,
+            clause: parseClause(m.clause),
+        };
+    });
+};
+const createMagicMatch = (value, mask, offset, type = "string") => {
+    const decodedValue = decodeString(value, type);
+    const decodedMask = mask ? decodeString(value, type) : undefined;
+    const patternLength = Math.max(decodedValue.length, decodedMask?.length ?? 0);
+    const resPattern = new Uint8Array(patternLength);
+    const resMask = new Uint8Array(patternLength);
+    for (let i = 0; i < patternLength; i++) {
+        if (decodedMask && i < decodedMask.length) {
+            resMask[i] = decodedMask[i];
+        }
+        else {
+            resMask[i] = -1;
+        }
+        if (i < decodedValue.length) {
+            resPattern[i] = decodedValue[i] & resMask[i];
+        }
+        else {
+            resPattern[i] = 0;
+        }
+    }
+    let start = 0;
+    let end = 0;
+    if (offset) {
+        if (offset.indexOf(":") > 0) {
+            const [startRaw, endRaw] = offset.split(":");
+            start = +startRaw;
+            end = +endRaw;
+        }
+        else {
+            start = +offset;
+            end = start;
+        }
+    }
+    return new MagicMatchClause(resPattern, resMask, start, end);
+};
+const magics = parseMagics(rawMagics);
+const detectContentType = (buffer) => {
+    if (buffer.length === 0) {
+        return undefined;
+    }
+    let result = [];
+    let currentPriority = -1;
+    for (const magic of magics) {
+        if (currentPriority > 0 && currentPriority > magic.priority) {
+            break;
+        }
+        if (magic.clause.eval(buffer)) {
+            if (currentPriority === magic.priority) {
+                result.push(magic.type);
+            }
+            else {
+                result = [magic.type];
+                currentPriority = magic.priority;
+            }
+        }
+    }
+    if (result.length > 0) {
+        return result[0];
+    }
+    return undefined;
+};
+export { detectContentType };

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export type * from "./model.js";
+export type * from "./reader.js";
+export * from "./resultFile.js";
+export { detectContentType } from "./detect.js";
+export { extension, lookupContentType } from "./utils.js";

package/dist/index.js

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

package/dist/model.d.ts

@@ -0,0 +1,92 @@
+export type RawTestStatus = "failed" | "broken" | "passed" | "skipped" | "unknown";
+export type RawMetadata = {
+    [key: string]: any;
+};
+export interface RawFixtureResult {
+    uuid?: string;
+    testResults?: string[];
+    type: "before" | "after";
+    name?: string;
+    start?: number;
+    stop?: number;
+    duration?: number;
+    status?: RawTestStatus;
+    message?: string;
+    trace?: string;
+    expected?: string;
+    actual?: string;
+    steps?: RawStep[];
+}
+export interface RawTestResult {
+    uuid?: string;
+    name?: string;
+    status?: RawTestStatus;
+    fullName?: string;
+    testId?: string;
+    testCaseName?: string;
+    historyId?: string;
+    description?: string;
+    descriptionHtml?: string;
+    precondition?: string;
+    preconditionHtml?: string;
+    expectedResult?: string;
+    expectedResultHtml?: string;
+    start?: number;
+    stop?: number;
+    duration?: number;
+    message?: string;
+    trace?: string;
+    expected?: string;
+    actual?: string;
+    flaky?: boolean;
+    muted?: boolean;
+    known?: boolean;
+    hostId?: string;
+    threadId?: string;
+    parameters?: RawTestParameter[];
+    steps?: RawStep[];
+    labels?: RawTestLabel[];
+    links?: RawTestLink[];
+}
+export interface RawTestLabel {
+    name?: string;
+    value?: string;
+}
+export interface RawTestLink {
+    name?: string;
+    url?: string;
+    type?: string;
+}
+export interface RawTestParameter {
+    name?: string;
+    value?: string;
+    hidden?: boolean;
+    excluded?: boolean;
+    masked?: boolean;
+}
+export type RawStep = RawTestStepResult | RawTestAttachment;
+export interface RawTestStepResult {
+    name?: string;
+    status?: RawTestStatus;
+    message?: string;
+    trace?: string;
+    actual?: string;
+    expected?: string;
+    start?: number;
+    stop?: number;
+    duration?: number;
+    parameters?: RawTestParameter[];
+    steps?: RawStep[];
+    type: "step";
+}
+export interface RawTestAttachment {
+    name?: string;
+    originalFileName?: string;
+    contentType?: string;
+    contentLength?: number;
+    optional?: boolean;
+    start?: number;
+    stop?: number;
+    duration?: number;
+    type: "attachment";
+}

package/dist/model.js

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

package/dist/reader.d.ts

@@ -0,0 +1,16 @@
+import type { ResultFile } from "@allurereport/plugin-api";
+import type { RawFixtureResult, RawMetadata, RawTestResult } from "./model.js";
+export interface ReaderContext {
+    readerId: string;
+    metadata?: RawMetadata;
+}
+export interface ResultsVisitor {
+    visitTestResult(result: RawTestResult, context: ReaderContext): Promise<void>;
+    visitTestFixtureResult(result: RawFixtureResult, context: ReaderContext): Promise<void>;
+    visitAttachmentFile(result: ResultFile, context: ReaderContext): Promise<void>;
+    visitMetadata(metadata: RawMetadata, context: ReaderContext): Promise<void>;
+}
+export interface ResultsReader {
+    read(visitor: ResultsVisitor, data: ResultFile): Promise<boolean>;
+    readerId(): string;
+}

package/dist/reader.js

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

package/dist/resultFile.d.ts

@@ -0,0 +1,39 @@
+import type { ResultFile } from "@allurereport/plugin-api";
+import { ReadStream } from "node:fs";
+import "node:fs/promises";
+import type { Readable } from "node:stream";
+export declare abstract class BaseResultFile implements ResultFile {
+    #private;
+    fileName: string;
+    extension: string | false;
+    contentType: string | undefined | false;
+    protected constructor(fileName: string);
+    protected abstract getContent(): ReadStream | undefined;
+    protected abstract readMagicHeader(): Uint8Array | undefined;
+    abstract getContentLength(): number | undefined;
+    getContentType(): string | undefined;
+    getOriginalFileName(): string;
+    getExtension(): string;
+    asJson<T>(): Promise<T | undefined>;
+    asUtf8String(): Promise<string | undefined>;
+    asBuffer(): Promise<Buffer | undefined>;
+    writeTo(path: string): Promise<void>;
+    readContent<T>(transform: (stream: ReadStream) => Promise<T | undefined>): Promise<T | undefined>;
+}
+export declare class BufferResultFile extends BaseResultFile {
+    buffer: Uint8Array;
+    constructor(buffer: Uint8Array, fileName: string);
+    protected getContent(): ReadStream;
+    protected readMagicHeader(): Uint8Array;
+    getContentLength(): number | undefined;
+}
+export declare class PathResultFile extends BaseResultFile {
+    path: string;
+    constructor(path: string, fileName?: string);
+    protected getContent(): ReadStream | undefined;
+    protected readMagicHeader(): Uint8Array | undefined;
+    getContentLength(): number | undefined;
+}
+export declare const readSteamToJson: <T>(stream: Readable) => Promise<T | undefined>;
+export declare const readStreamToString: (stream: Readable) => Promise<string>;
+export declare const readStreamToBuffer: (stream: Readable) => Promise<Buffer>;

package/dist/resultFile.js

@@ -0,0 +1,135 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BaseResultFile_instances, _BaseResultFile_detectContentType;
+import { lookup } from "mime-types";
+import { ReadStream, closeSync, createReadStream, createWriteStream, existsSync, openSync, readSync, statSync, } from "node:fs";
+import "node:fs/promises";
+import { basename } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { detectContentType } from "./detect.js";
+import { extension } from "./utils.js";
+export class BaseResultFile {
+    constructor(fileName) {
+        _BaseResultFile_instances.add(this);
+        this.extension = false;
+        this.contentType = false;
+        this.fileName = fileName;
+    }
+    getContentType() {
+        if (this.contentType === false) {
+            this.contentType = __classPrivateFieldGet(this, _BaseResultFile_instances, "m", _BaseResultFile_detectContentType).call(this);
+        }
+        return this.contentType;
+    }
+    getOriginalFileName() {
+        return this.fileName;
+    }
+    getExtension() {
+        if (this.extension === false) {
+            this.extension = extension(this.getOriginalFileName()) ?? extension("", this.getContentType()) ?? "";
+        }
+        return this.extension;
+    }
+    async asJson() {
+        return await this.readContent(readSteamToJson);
+    }
+    async asUtf8String() {
+        return await this.readContent(readStreamToString);
+    }
+    async asBuffer() {
+        return await this.readContent(readStreamToBuffer);
+    }
+    async writeTo(path) {
+        await this.readContent(async (stream) => {
+            await pipeline(stream, createWriteStream(path));
+        });
+    }
+    async readContent(transform) {
+        const content = this.getContent();
+        return content ? await transform(content) : undefined;
+    }
+}
+_BaseResultFile_instances = new WeakSet(), _BaseResultFile_detectContentType = function _BaseResultFile_detectContentType() {
+    const res = lookup(this.getOriginalFileName());
+    if (res === false) {
+        const magicHeader = this.readMagicHeader();
+        if (!magicHeader) {
+            return undefined;
+        }
+        return detectContentType(magicHeader);
+    }
+    return res;
+};
+const magicHeaderLength = 1024;
+export class BufferResultFile extends BaseResultFile {
+    constructor(buffer, fileName) {
+        super(basename(fileName));
+        this.buffer = buffer;
+    }
+    getContent() {
+        return ReadStream.from(this.buffer);
+    }
+    readMagicHeader() {
+        return this.buffer.subarray(0, magicHeaderLength);
+    }
+    getContentLength() {
+        return this.buffer.length;
+    }
+}
+export class PathResultFile extends BaseResultFile {
+    constructor(path, fileName = basename(path)) {
+        super(fileName);
+        this.path = path;
+    }
+    getContent() {
+        if (existsSync(this.path)) {
+            return createReadStream(this.path);
+        }
+        else {
+            return undefined;
+        }
+    }
+    readMagicHeader() {
+        if (existsSync(this.path)) {
+            const buf = new Uint8Array(magicHeaderLength);
+            const fd = openSync(this.path, "r");
+            try {
+                const size = readSync(fd, buf, 0, magicHeaderLength, null);
+                if (size === 0) {
+                    return undefined;
+                }
+                if (size < magicHeaderLength) {
+                    return buf.subarray(0, size);
+                }
+                return buf;
+            }
+            finally {
+                closeSync(fd);
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+    getContentLength() {
+        return statSync(this.path, { throwIfNoEntry: false })?.size;
+    }
+}
+export const readSteamToJson = async (stream) => {
+    const text = await readStreamToString(stream);
+    return JSON.parse(text);
+};
+export const readStreamToString = async (stream) => {
+    const res = await readStreamToBuffer(stream);
+    return res.toString("utf-8");
+};
+export const readStreamToBuffer = async (stream) => {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+};

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const extension: (fileName: string, contentType?: string) => string | undefined;
+export declare const lookupContentType: (fileName: string) => string | undefined;

package/dist/utils.js

@@ -0,0 +1,23 @@
+import { extension as extensionFromContentType, lookup } from "mime-types";
+import { extname } from "node:path";
+export const extension = (fileName, contentType) => {
+    const ext = extname(fileName);
+    if (ext !== "") {
+        return ext;
+    }
+    if (contentType) {
+        const result = extensionFromContentType(contentType);
+        if (result === false) {
+            return undefined;
+        }
+        return `.${result}`;
+    }
+    return undefined;
+};
+export const lookupContentType = (fileName) => {
+    const res = lookup(fileName);
+    if (res === false) {
+        return undefined;
+    }
+    return res;
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@allurereport/reader-api",
+  "version": "3.0.0-beta.10",
+  "description": "Allure Reader API",
+  "keywords": [
+    "allure",
+    "testing"
+  ],
+  "repository": "https://github.com/allure-framework/allure3",
+  "license": "Apache-2.0",
+  "author": "Qameta Software",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "main": "./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",
+    "eslint": "eslint ./src/**/*.{js,jsx,ts,tsx}",
+    "eslint:format": "eslint --fix ./src/**/*.{js,jsx,ts,tsx}",
+    "test": "rimraf ./out && vitest run"
+  },
+  "dependencies": {
+    "@allurereport/core-api": "3.0.0-beta.10",
+    "@allurereport/plugin-api": "3.0.0-beta.10",
+    "mime-types": "^2.1.35"
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2.6.1",
+    "@types/eslint": "^8.56.11",
+    "@types/mime-types": "^2.1.4",
+    "@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",
+    "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",
+    "ts-node": "^10.9.2",
+    "tslib": "^2.7.0",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
+  }
+}