jest-allure2-reporter/dist/options/resolveWriter.js

Idiomatic Jest reporter for Allure Framework

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.resolveWriter = resolveWriter;
const tslib_1 = require("tslib");
const import_from_1 = tslib_1.__importDefault(require("import-from"));
async function resolveWriter(rootDirectory, config) {
    let result;
    const writerOption = config.writer;
    let WriterImpl = writerOption;
    let customOptions = {};
    // Handle array pattern [WriterImpl, customOptions]
    if (Array.isArray(writerOption)) {
        [WriterImpl, customOptions = {}] = writerOption;
    }
    if (typeof WriterImpl === 'string') {
        const imported = (0, import_from_1.default)(rootDirectory, WriterImpl);
        WriterImpl = imported?.default || imported;
    }
    // If it's a function/constructor
    if (isMaybeClass(WriterImpl)) {
        try {
            result = await WriterImpl(config, customOptions);
        }
        catch (constructorError) {
            try {
                result = new WriterImpl(config, customOptions);
            }
            catch (factoryError) {
                throw new Error(`Failed to instantiate AllureWriter: ${constructorError?.message || constructorError}. ` +
                    `Also failed as factory: ${factoryError?.message || factoryError}`);
            }
        }
    }
    result ??= WriterImpl;
    if (result == null) {
        throw new TypeError('AllureWriter implementation is undefined or null');
    }
    if (typeof result !== 'object') {
        throw new TypeError('AllureWriter implementation must be a class or function, but got: ' + result);
    }
    const missingMethods = findMissingMethods(result);
    if (missingMethods.length > 0) {
        throw new TypeError(`AllureWriter implementation is missing required methods: ${missingMethods.join(', ')}`);
    }
    return result;
}
const REQUIRED_METHODS = [
    'writeCategories',
    'writeEnvironmentInfo',
    'writeExecutorInfo',
    'writeContainer',
    'writeResult',
];
function findMissingMethods(object) {
    if (!object || typeof object !== 'object') {
        return [...REQUIRED_METHODS];
    }
    return REQUIRED_METHODS.filter((key) => {
        const hopefullyFunction = object[key];
        return typeof hopefullyFunction !== 'function';
    });
}
function isMaybeClass(value) {
    return typeof value === 'function';
}
//# sourceMappingURL=resolveWriter.js.map