@tiden/reporter-commons 0.1.0

package/dist/core/options-resolver.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionsResolver = void 0;
+const env_schema_1 = __importDefault(require("env-schema"));
+const env_1 = require("../env");
+const options_1 = require("../options");
+const state_1 = require("../state/state");
+/**
+ * Composes the final options used by TidenReporter:
+ * - restores mode / runId from state (when withState is active)
+ * - merges env-derived config with user options
+ * - determines effective mode / fallback values
+ */
+class OptionsResolver {
+    resolve(options) {
+        const withState = this.detectWithState(options);
+        if (withState) {
+            this.restoreFromState();
+        }
+        const env = (0, env_1.envToConfig)((0, env_schema_1.default)({ schema: env_1.envValidationSchema }));
+        const composed = (0, options_1.composeOptions)(options, env);
+        return {
+            effectiveMode: composed.mode ?? options_1.ModeEnum.off,
+            effectiveFallback: composed.fallback ?? options_1.ModeEnum.off,
+            composed,
+            withState,
+        };
+    }
+    detectWithState(options) {
+        return options.frameworkName === 'cypress' || !options.frameworkName;
+    }
+    restoreFromState() {
+        if (!state_1.StateManager.isStateExists())
+            return;
+        const state = state_1.StateManager.getState();
+        if (state.IsModeChanged && state.Mode) {
+            process.env[env_1.EnvEnum.mode] = state.Mode.toString();
+        }
+        if (state.RunId) {
+            process.env[env_1.EnvRunEnum.id] = state.RunId.toString();
+        }
+    }
+}
+exports.OptionsResolver = OptionsResolver;

package/dist/core/reporter-factory.d.ts

@@ -0,0 +1,18 @@
+import { InternalReporterInterface } from '../reporters';
+import { ModeEnum, OptionsType } from '../options';
+import { ConfigType } from '../config';
+import { LoggerInterface } from '../utils/logger';
+import { HostData } from '../models/host-data';
+/**
+ * Builds a mode-specific InternalReporterInterface. Throws DisabledException
+ * for `ModeEnum.off` so callers can distinguish "disabled-by-config" from a
+ * real failure.
+ */
+export declare class ReporterFactory {
+    private readonly logger;
+    private readonly hostData;
+    constructor(logger: LoggerInterface, hostData: HostData);
+    create(mode: ModeEnum, options: ConfigType & OptionsType, withState: boolean): InternalReporterInterface;
+    private createRunReporter;
+    private createReport;
+}

package/dist/core/reporter-factory.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReporterFactory = void 0;
+const reporters_1 = require("../reporters");
+const options_1 = require("../options");
+const env_1 = require("../env");
+const disabled_exception_1 = require("../utils/disabled-exception");
+const tiden_client_1 = require("../client/tiden-client");
+const writer_1 = require("../writer");
+/**
+ * Builds a mode-specific InternalReporterInterface. Throws DisabledException
+ * for `ModeEnum.off` so callers can distinguish "disabled-by-config" from a
+ * real failure.
+ */
+class ReporterFactory {
+    logger;
+    hostData;
+    constructor(logger, hostData) {
+        this.logger = logger;
+        this.hostData = hostData;
+    }
+    create(mode, options, withState) {
+        switch (mode) {
+            case options_1.ModeEnum.tiden:
+                return this.createRunReporter(options, withState);
+            case options_1.ModeEnum.report:
+                return this.createReport(options);
+            case options_1.ModeEnum.off:
+                throw new disabled_exception_1.DisabledException();
+            default:
+                throw new Error(`Unknown mode type`);
+        }
+    }
+    createRunReporter(options, withState) {
+        if (!options.tiden?.api?.token) {
+            throw new Error(`Either "tiden.api.token" parameter or "${env_1.EnvApiEnum.token}" environment variable is required in "tiden" mode`);
+        }
+        if (!options.tiden.product) {
+            throw new Error(`Either "tiden.product" parameter or "${env_1.EnvTidenEnum.product}" environment variable is required in "tiden" mode`);
+        }
+        if (!options.tiden?.api?.baseUrl) {
+            throw new Error(`Either "tiden.api.baseUrl" parameter or "${env_1.EnvApiEnum.baseUrl}" environment variable is required in "tiden" mode`);
+        }
+        const tiden = options.tiden;
+        tiden.clientMeta = {
+            framework: options.frameworkName ?? '',
+            reporter: options.reporterName ?? '',
+            framework_version: this.hostData.framework,
+            reporter_version: this.hostData.reporter,
+            commons_version: this.hostData.commons,
+            os: this.hostData.system,
+            node: this.hostData.language,
+        };
+        const apiClient = new tiden_client_1.TidenApiClient(this.logger, tiden, options.environment, options.rootSuite);
+        return new reporters_1.RunReporter(this.logger, apiClient, withState, tiden.product, tiden.batch?.size, tiden.run?.id);
+    }
+    createReport(options) {
+        const localOptions = options.report?.connections?.[writer_1.DriverEnum.local];
+        const writer = new writer_1.FsWriter(localOptions);
+        return new reporters_1.ReportReporter(this.logger, writer, options.frameworkPackage, options.reporterName, options.environment, options.rootSuite, options.tiden?.run?.id, this.hostData);
+    }
+}
+exports.ReporterFactory = ReporterFactory;

package/dist/core/status-processor.d.ts

@@ -0,0 +1,17 @@
+import { TestResultType } from '../models';
+import { LoggerInterface } from '../utils/logger';
+/**
+ * Applies status mapping (rename rule) and status filter (drop rule) to a test
+ * result. Mutates `result.execution.status` when a mapping rule matches, then
+ * returns either the (possibly mutated) result or `null` if it should be
+ * filtered out.
+ */
+export declare class StatusProcessor {
+    private readonly logger;
+    private readonly statusMapping;
+    private readonly statusFilter;
+    constructor(logger: LoggerInterface, statusMapping: Record<string, string> | undefined, statusFilter: string[] | undefined);
+    process(result: TestResultType): TestResultType | null;
+    private applyMapping;
+    private shouldFilter;
+}

package/dist/core/status-processor.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusProcessor = void 0;
+const status_mapping_utils_1 = require("../utils/status-mapping-utils");
+/**
+ * Applies status mapping (rename rule) and status filter (drop rule) to a test
+ * result. Mutates `result.execution.status` when a mapping rule matches, then
+ * returns either the (possibly mutated) result or `null` if it should be
+ * filtered out.
+ */
+class StatusProcessor {
+    logger;
+    statusMapping;
+    statusFilter;
+    constructor(logger, statusMapping, statusFilter) {
+        this.logger = logger;
+        this.statusMapping = statusMapping;
+        this.statusFilter = statusFilter;
+    }
+    process(result) {
+        this.applyMapping(result);
+        if (this.shouldFilter(result)) {
+            this.logger.logDebug(`Filtering out test result with status: ${result.execution.status}`);
+            return null;
+        }
+        return result;
+    }
+    applyMapping(result) {
+        if (!this.statusMapping)
+            return;
+        const originalStatus = result.execution.status;
+        const mapped = (0, status_mapping_utils_1.applyStatusMapping)(originalStatus, this.statusMapping);
+        if (mapped !== originalStatus) {
+            this.logger.logDebug(`Status mapping applied: ${originalStatus} -> ${mapped}`);
+            result.execution.status = mapped;
+        }
+    }
+    shouldFilter(result) {
+        if (!this.statusFilter || this.statusFilter.length === 0)
+            return false;
+        const statusString = result.execution.status.toString();
+        this.logger.logDebug(`Checking filter: status="${statusString}", filter=${JSON.stringify(this.statusFilter)}`);
+        const shouldFilter = this.statusFilter.includes(statusString);
+        this.logger.logDebug(`Filter result: ${shouldFilter ? 'FILTERED' : 'NOT FILTERED'}`);
+        return shouldFilter;
+    }
+}
+exports.StatusProcessor = StatusProcessor;

package/dist/env/env-enum.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @enum {string}
+ */
+export declare enum EnvEnum {
+    mode = "TIDEN_MODE",
+    fallback = "TIDEN_FALLBACK",
+    debug = "TIDEN_DEBUG",
+    environment = "TIDEN_ENVIRONMENT",
+    captureLogs = "TIDEN_CAPTURE_LOGS",
+    rootSuite = "TIDEN_ROOT_SUITE",
+    statusMapping = "TIDEN_STATUS_MAPPING"
+}
+/**
+ * @enum {string}
+ */
+export declare enum EnvTidenEnum {
+    product = "TIDEN_PRODUCT_ID",
+    uploadAttachments = "TIDEN_UPLOAD_ATTACHMENTS",
+    defect = "TIDEN_DEFECT",
+    statusFilter = "TIDEN_STATUS_FILTER"
+}
+/**
+ * @enum {string}
+ */
+export declare enum EnvApiEnum {
+    token = "TIDEN_API_TOKEN",
+    baseUrl = "TIDEN_BASE_URL"
+}
+/**
+ * @enum {string}
+ */
+export declare enum EnvRunEnum {
+    id = "TIDEN_RUN_ID",
+    title = "TIDEN_RUN_TITLE",
+    description = "TIDEN_RUN_DESCRIPTION",
+    complete = "TIDEN_RUN_COMPLETE",
+    branch = "TIDEN_BRANCH"
+}
+/**
+ * @enum {string}
+ */
+export declare enum EnvBatchEnum {
+    size = "TIDEN_BATCH_SIZE"
+}
+/**
+ * @enum {string}
+ */
+export declare enum EnvConfigurationsEnum {
+    values = "TIDEN_CONFIGURATIONS_VALUES"
+}
+/**
+ * @enum {string}
+ */
+export declare enum EnvLocalEnum {
+    path = "TIDEN_REPORT_CONNECTION_PATH",
+    format = "TIDEN_REPORT_CONNECTION_FORMAT"
+}
+/**
+ * @enum {string}
+ */
+export declare enum EnvLoggingEnum {
+    console = "TIDEN_LOGGING_CONSOLE",
+    file = "TIDEN_LOGGING_FILE"
+}

package/dist/env/env-enum.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvLoggingEnum = exports.EnvLocalEnum = exports.EnvConfigurationsEnum = exports.EnvBatchEnum = exports.EnvRunEnum = exports.EnvApiEnum = exports.EnvTidenEnum = exports.EnvEnum = void 0;
+/**
+ * @enum {string}
+ */
+var EnvEnum;
+(function (EnvEnum) {
+    EnvEnum["mode"] = "TIDEN_MODE";
+    EnvEnum["fallback"] = "TIDEN_FALLBACK";
+    EnvEnum["debug"] = "TIDEN_DEBUG";
+    EnvEnum["environment"] = "TIDEN_ENVIRONMENT";
+    EnvEnum["captureLogs"] = "TIDEN_CAPTURE_LOGS";
+    EnvEnum["rootSuite"] = "TIDEN_ROOT_SUITE";
+    EnvEnum["statusMapping"] = "TIDEN_STATUS_MAPPING";
+})(EnvEnum || (exports.EnvEnum = EnvEnum = {}));
+/**
+ * @enum {string}
+ */
+var EnvTidenEnum;
+(function (EnvTidenEnum) {
+    EnvTidenEnum["product"] = "TIDEN_PRODUCT_ID";
+    EnvTidenEnum["uploadAttachments"] = "TIDEN_UPLOAD_ATTACHMENTS";
+    EnvTidenEnum["defect"] = "TIDEN_DEFECT";
+    EnvTidenEnum["statusFilter"] = "TIDEN_STATUS_FILTER";
+})(EnvTidenEnum || (exports.EnvTidenEnum = EnvTidenEnum = {}));
+/**
+ * @enum {string}
+ */
+var EnvApiEnum;
+(function (EnvApiEnum) {
+    EnvApiEnum["token"] = "TIDEN_API_TOKEN";
+    EnvApiEnum["baseUrl"] = "TIDEN_BASE_URL";
+})(EnvApiEnum || (exports.EnvApiEnum = EnvApiEnum = {}));
+/**
+ * @enum {string}
+ */
+var EnvRunEnum;
+(function (EnvRunEnum) {
+    EnvRunEnum["id"] = "TIDEN_RUN_ID";
+    EnvRunEnum["title"] = "TIDEN_RUN_TITLE";
+    EnvRunEnum["description"] = "TIDEN_RUN_DESCRIPTION";
+    EnvRunEnum["complete"] = "TIDEN_RUN_COMPLETE";
+    EnvRunEnum["branch"] = "TIDEN_BRANCH";
+})(EnvRunEnum || (exports.EnvRunEnum = EnvRunEnum = {}));
+/**
+ * @enum {string}
+ */
+var EnvBatchEnum;
+(function (EnvBatchEnum) {
+    EnvBatchEnum["size"] = "TIDEN_BATCH_SIZE";
+})(EnvBatchEnum || (exports.EnvBatchEnum = EnvBatchEnum = {}));
+/**
+ * @enum {string}
+ */
+var EnvConfigurationsEnum;
+(function (EnvConfigurationsEnum) {
+    EnvConfigurationsEnum["values"] = "TIDEN_CONFIGURATIONS_VALUES";
+})(EnvConfigurationsEnum || (exports.EnvConfigurationsEnum = EnvConfigurationsEnum = {}));
+/**
+ * @enum {string}
+ */
+var EnvLocalEnum;
+(function (EnvLocalEnum) {
+    EnvLocalEnum["path"] = "TIDEN_REPORT_CONNECTION_PATH";
+    EnvLocalEnum["format"] = "TIDEN_REPORT_CONNECTION_FORMAT";
+})(EnvLocalEnum || (exports.EnvLocalEnum = EnvLocalEnum = {}));
+/**
+ * @enum {string}
+ */
+var EnvLoggingEnum;
+(function (EnvLoggingEnum) {
+    EnvLoggingEnum["console"] = "TIDEN_LOGGING_CONSOLE";
+    EnvLoggingEnum["file"] = "TIDEN_LOGGING_FILE";
+})(EnvLoggingEnum || (exports.EnvLoggingEnum = EnvLoggingEnum = {}));

package/dist/env/env-to-config.d.ts

@@ -0,0 +1,7 @@
+import { EnvType } from './env-type';
+import { ConfigType } from '../config';
+/**
+ * @param {EnvType} env
+ * @returns {ConfigType}
+ */
+export declare const envToConfig: (env: EnvType) => ConfigType;

package/dist/env/env-to-config.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envToConfig = void 0;
+const env_enum_1 = require("./env-enum");
+const writer_1 = require("../writer");
+/**
+ * @param {EnvType} env
+ * @returns {ConfigType}
+ */
+const envToConfig = (env) => ({
+    mode: env[env_enum_1.EnvEnum.mode],
+    debug: env[env_enum_1.EnvEnum.debug],
+    environment: env[env_enum_1.EnvEnum.environment],
+    captureLogs: env[env_enum_1.EnvEnum.captureLogs],
+    rootSuite: env[env_enum_1.EnvEnum.rootSuite],
+    statusMapping: env[env_enum_1.EnvEnum.statusMapping] ?
+        Object.fromEntries(env[env_enum_1.EnvEnum.statusMapping].split(',').map(item => {
+            const [from, to] = item.split('=');
+            return [from?.trim() || '', to?.trim() || ''];
+        })) : undefined,
+    tiden: {
+        product: env[env_enum_1.EnvTidenEnum.product],
+        uploadAttachments: env[env_enum_1.EnvTidenEnum.uploadAttachments],
+        statusFilter: env[env_enum_1.EnvTidenEnum.statusFilter]?.split(',').map(status => status.trim()) ?? undefined,
+        api: {
+            token: env[env_enum_1.EnvApiEnum.token],
+            baseUrl: env[env_enum_1.EnvApiEnum.baseUrl],
+        },
+        run: {
+            id: env[env_enum_1.EnvRunEnum.id],
+            title: env[env_enum_1.EnvRunEnum.title],
+            description: env[env_enum_1.EnvRunEnum.description],
+            complete: env[env_enum_1.EnvRunEnum.complete],
+            branch: env[env_enum_1.EnvRunEnum.branch],
+        },
+        batch: {
+            size: env[env_enum_1.EnvBatchEnum.size],
+        },
+        defect: env[env_enum_1.EnvTidenEnum.defect],
+        configurations: env[env_enum_1.EnvConfigurationsEnum.values] ? {
+            values: env[env_enum_1.EnvConfigurationsEnum.values].split(',').map(item => {
+                const [name, value] = item.split('=');
+                return { name: (name ?? '').trim(), value: value ? value.trim() : '' };
+            }),
+        } : undefined,
+    },
+    report: {
+        connections: {
+            [writer_1.DriverEnum.local]: {
+                path: env[env_enum_1.EnvLocalEnum.path],
+                format: env[env_enum_1.EnvLocalEnum.format],
+            },
+        },
+    },
+    logging: (env[env_enum_1.EnvLoggingEnum.console] !== undefined || env[env_enum_1.EnvLoggingEnum.file] !== undefined) ? {
+        console: env[env_enum_1.EnvLoggingEnum.console],
+        file: env[env_enum_1.EnvLoggingEnum.file],
+    } : undefined,
+});
+exports.envToConfig = envToConfig;

package/dist/env/env-type.d.ts

@@ -0,0 +1,29 @@
+import { EnvEnum, EnvTidenEnum, EnvApiEnum, EnvRunEnum, EnvLocalEnum, EnvBatchEnum, EnvConfigurationsEnum, EnvLoggingEnum } from './env-enum';
+import { ModeEnum } from '../options';
+import { FormatEnum } from '../writer';
+export interface EnvType {
+    [EnvEnum.mode]?: `${ModeEnum}`;
+    [EnvEnum.fallback]?: `${ModeEnum}`;
+    [EnvEnum.debug]?: boolean;
+    [EnvEnum.environment]?: string;
+    [EnvEnum.captureLogs]?: boolean;
+    [EnvEnum.rootSuite]?: string;
+    [EnvEnum.statusMapping]?: string;
+    [EnvTidenEnum.product]?: string;
+    [EnvTidenEnum.uploadAttachments]?: boolean;
+    [EnvTidenEnum.defect]?: boolean;
+    [EnvTidenEnum.statusFilter]?: string;
+    [EnvApiEnum.token]?: string;
+    [EnvApiEnum.baseUrl]?: string;
+    [EnvRunEnum.id]?: number;
+    [EnvRunEnum.title]?: string;
+    [EnvRunEnum.description]?: string;
+    [EnvRunEnum.complete]?: boolean;
+    [EnvRunEnum.branch]?: string;
+    [EnvBatchEnum.size]?: number;
+    [EnvConfigurationsEnum.values]?: string;
+    [EnvLocalEnum.path]?: string;
+    [EnvLocalEnum.format]?: `${FormatEnum}`;
+    [EnvLoggingEnum.console]?: boolean;
+    [EnvLoggingEnum.file]?: boolean;
+}

package/dist/env/env-type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const env_enum_1 = require("./env-enum");

package/dist/env/env-validation-schema.d.ts

@@ -0,0 +1,6 @@
+import { JSONSchemaType } from 'env-schema';
+import { EnvType } from './env-type';
+/**
+ * @type {JSONSchemaType<EnvType>}
+ */
+export declare const envValidationSchema: JSONSchemaType<EnvType>;

package/dist/env/env-validation-schema.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envValidationSchema = void 0;
+const env_enum_1 = require("./env-enum");
+const options_1 = require("../options");
+const writer_1 = require("../writer");
+/**
+ * @type {JSONSchemaType<EnvType>}
+ */
+exports.envValidationSchema = {
+    type: 'object',
+    properties: {
+        [env_enum_1.EnvEnum.mode]: {
+            type: 'string',
+            enum: [options_1.ModeEnum.report, options_1.ModeEnum.tiden, options_1.ModeEnum.off],
+            nullable: true,
+        },
+        [env_enum_1.EnvEnum.fallback]: {
+            type: 'string',
+            enum: [options_1.ModeEnum.report, options_1.ModeEnum.tiden, options_1.ModeEnum.off],
+            nullable: true,
+        },
+        [env_enum_1.EnvEnum.debug]: {
+            type: 'boolean',
+            nullable: true,
+        },
+        [env_enum_1.EnvEnum.environment]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvEnum.captureLogs]: {
+            type: 'boolean',
+            nullable: true,
+        },
+        [env_enum_1.EnvEnum.rootSuite]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvEnum.statusMapping]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvTidenEnum.product]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvTidenEnum.uploadAttachments]: {
+            type: 'boolean',
+            nullable: true,
+        },
+        [env_enum_1.EnvTidenEnum.defect]: {
+            type: 'boolean',
+            nullable: true,
+        },
+        [env_enum_1.EnvTidenEnum.statusFilter]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvApiEnum.token]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvApiEnum.baseUrl]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvRunEnum.id]: {
+            type: 'number',
+            nullable: true,
+        },
+        [env_enum_1.EnvRunEnum.title]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvRunEnum.description]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvRunEnum.complete]: {
+            type: 'boolean',
+            nullable: true,
+        },
+        [env_enum_1.EnvRunEnum.branch]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvBatchEnum.size]: {
+            type: 'number',
+            nullable: true,
+        },
+        [env_enum_1.EnvConfigurationsEnum.values]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvLocalEnum.path]: {
+            type: 'string',
+            nullable: true,
+        },
+        [env_enum_1.EnvLocalEnum.format]: {
+            type: 'string',
+            enum: [writer_1.FormatEnum.json, writer_1.FormatEnum.jsonp],
+            nullable: true,
+        },
+        [env_enum_1.EnvLoggingEnum.console]: {
+            type: 'boolean',
+            nullable: true,
+        },
+        [env_enum_1.EnvLoggingEnum.file]: {
+            type: 'boolean',
+            nullable: true,
+        },
+    },
+};

package/dist/env/index.d.ts

@@ -0,0 +1,4 @@
+export { EnvEnum, EnvTidenEnum, EnvApiEnum, EnvRunEnum, EnvLocalEnum, } from './env-enum';
+export { type EnvType } from './env-type';
+export { envValidationSchema } from './env-validation-schema';
+export { envToConfig } from './env-to-config';

package/dist/env/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envToConfig = exports.envValidationSchema = exports.EnvLocalEnum = exports.EnvRunEnum = exports.EnvApiEnum = exports.EnvTidenEnum = exports.EnvEnum = void 0;
+var env_enum_1 = require("./env-enum");
+Object.defineProperty(exports, "EnvEnum", { enumerable: true, get: function () { return env_enum_1.EnvEnum; } });
+Object.defineProperty(exports, "EnvTidenEnum", { enumerable: true, get: function () { return env_enum_1.EnvTidenEnum; } });
+Object.defineProperty(exports, "EnvApiEnum", { enumerable: true, get: function () { return env_enum_1.EnvApiEnum; } });
+Object.defineProperty(exports, "EnvRunEnum", { enumerable: true, get: function () { return env_enum_1.EnvRunEnum; } });
+Object.defineProperty(exports, "EnvLocalEnum", { enumerable: true, get: function () { return env_enum_1.EnvLocalEnum; } });
+var env_validation_schema_1 = require("./env-validation-schema");
+Object.defineProperty(exports, "envValidationSchema", { enumerable: true, get: function () { return env_validation_schema_1.envValidationSchema; } });
+var env_to_config_1 = require("./env-to-config");
+Object.defineProperty(exports, "envToConfig", { enumerable: true, get: function () { return env_to_config_1.envToConfig; } });

package/dist/formatter/formatter-interface.d.ts

@@ -0,0 +1,3 @@
+export interface FormatterInterface {
+    format(result: unknown): Promise<string>;
+}

package/dist/formatter/formatter-interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/formatter/index.d.ts

@@ -0,0 +1,4 @@
+export { type FormatterInterface } from './formatter-interface';
+export { JsonFormatter } from './json-formatter';
+export { JsonpFormatter } from './jsonp-formatter';
+export { ReportSerializer, type ReportSerializerInterface } from './report-serializer';

package/dist/formatter/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportSerializer = exports.JsonpFormatter = exports.JsonFormatter = void 0;
+var json_formatter_1 = require("./json-formatter");
+Object.defineProperty(exports, "JsonFormatter", { enumerable: true, get: function () { return json_formatter_1.JsonFormatter; } });
+var jsonp_formatter_1 = require("./jsonp-formatter");
+Object.defineProperty(exports, "JsonpFormatter", { enumerable: true, get: function () { return jsonp_formatter_1.JsonpFormatter; } });
+var report_serializer_1 = require("./report-serializer");
+Object.defineProperty(exports, "ReportSerializer", { enumerable: true, get: function () { return report_serializer_1.ReportSerializer; } });

package/dist/formatter/json-formatter.d.ts

@@ -0,0 +1,13 @@
+import { FormatterInterface } from './formatter-interface';
+export interface JsonFormatterOptionsType {
+    space?: number | undefined;
+}
+/**
+ * @class JsonFormatter
+ * @implements FormatterInterface
+ */
+export declare class JsonFormatter implements FormatterInterface {
+    private space;
+    constructor(options?: JsonFormatterOptionsType);
+    format(object: unknown): Promise<string>;
+}

package/dist/formatter/json-formatter.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonFormatter = void 0;
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
+/**
+ * @class JsonFormatter
+ * @implements FormatterInterface
+ */
+class JsonFormatter {
+    space;
+    constructor(options = {}) {
+        const { space = 4 } = options;
+        this.space = space;
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async format(object) {
+        return JSON.stringify(object, (key, value) => {
+            if (key === 'error' && value instanceof Error) {
+                return (0, strip_ansi_1.default)(String(value));
+            }
+            return value;
+        }, this.space);
+    }
+}
+exports.JsonFormatter = JsonFormatter;

package/dist/formatter/jsonp-formatter.d.ts

@@ -0,0 +1,13 @@
+import { FormatterInterface } from './formatter-interface';
+export interface JsonpFormatterOptionsType {
+    space?: number | undefined;
+}
+/**
+ * @class JsonFormatter
+ * @implements FormatterInterface
+ */
+export declare class JsonpFormatter implements FormatterInterface {
+    private space;
+    constructor(options?: JsonpFormatterOptionsType);
+    format(object: unknown): Promise<string>;
+}