@mablhq/playwright-tools 2.49.1

package/core/execution/MailboxConstants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EMAIL_LOOKBACK_TIME_MILLISECONDS = void 0;
+exports.DEFAULT_EMAIL_LOOKBACK_TIME_MILLISECONDS = 1000 * 60 * 10;

package/core/execution/PostmanUtils.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeExportedVariables = exports.exportVariables = exports.convertVariablesSummaryToPostmanFormat = void 0;
+const VariableUtils_1 = require("./VariableUtils");
+const domUtil_1 = require("../../domUtil");
+function convertVariablesSummaryToPostmanFormat(summary) {
+    const effectiveVariables = { ...summary.effective };
+    const values = Object.keys(effectiveVariables).map((key) => ({
+        key,
+        value: effectiveVariables[key],
+    }));
+    return {
+        values,
+    };
+}
+exports.convertVariablesSummaryToPostmanFormat = convertVariablesSummaryToPostmanFormat;
+function exportVariables(postmanResult) {
+    const variablePrecedence = [
+        postmanResult === null || postmanResult === void 0 ? void 0 : postmanResult.globals.values,
+        postmanResult === null || postmanResult === void 0 ? void 0 : postmanResult.collection.variables,
+        postmanResult === null || postmanResult === void 0 ? void 0 : postmanResult.environment.values,
+    ].filter((variables) => !!variables);
+    const exportedVariables = {};
+    variablePrecedence
+        .map((variableList) => variableList.all())
+        .forEach((variables) => variables.forEach((variable) => (exportedVariables[variable.key] = variable.value)));
+    return exportedVariables;
+}
+exports.exportVariables = exportVariables;
+function sanitizeExportedVariables(variables) {
+    const normalized = {};
+    if (variables) {
+        return normalizeExportedVariables(filterExportedVariables(variables));
+    }
+    return normalized;
+}
+exports.sanitizeExportedVariables = sanitizeExportedVariables;
+function normalizeExportedVariables(variables) {
+    const normalized = {};
+    Object.keys(variables).forEach((name) => {
+        normalized[(0, VariableUtils_1.addUserNamespace)(name)] = variables[name];
+    });
+    return normalized;
+}
+function filterExportedVariables(variables) {
+    const filtered = {};
+    Object.keys(variables)
+        .filter((name) => (0, domUtil_1.isValidUserVariableName)(name))
+        .forEach((name) => {
+        filtered[name] = variables[name];
+    });
+    return filtered;
+}

package/core/execution/RunConfig.js

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

package/core/execution/TestResult.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isApiTestResult = exports.TestResultStatus = void 0;
+var TestResultStatus;
+(function (TestResultStatus) {
+    TestResultStatus["failed"] = "failed";
+    TestResultStatus["passed"] = "passed";
+    TestResultStatus["skipped"] = "skipped";
+    TestResultStatus["stopped"] = "stopped";
+    TestResultStatus["terminated"] = "terminated";
+})(TestResultStatus || (exports.TestResultStatus = TestResultStatus = {}));
+function isApiTestResult(result) {
+    return 'flowResults' in result;
+}
+exports.isApiTestResult = isApiTestResult;

package/core/execution/VariableUtils.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findUsedVariables = exports.addUserNamespace = exports.generateVariablesSummaryForExport = exports.generateVariablesSummaryForImport = exports.API_CREDENTIALS_PASSWORD_VARIABLE_NAME = exports.API_CREDENTIALS_USERNAME_VARIABLE_NAME = exports.API_CREDENTIALS_NAMESPACE = exports.API_URL_VARIABLE_NAME = exports.API_NAMESPACE = exports.FLOW_NAMESPACE = exports.USER_NAMESPACE = void 0;
+const domUtil_1 = require("../../domUtil");
+exports.USER_NAMESPACE = 'user.';
+exports.FLOW_NAMESPACE = 'flow.';
+exports.API_NAMESPACE = 'api.';
+exports.API_URL_VARIABLE_NAME = `${exports.API_NAMESPACE}url`;
+exports.API_CREDENTIALS_NAMESPACE = `${exports.API_NAMESPACE}credentials.`;
+exports.API_CREDENTIALS_USERNAME_VARIABLE_NAME = `${exports.API_CREDENTIALS_NAMESPACE}username`;
+exports.API_CREDENTIALS_PASSWORD_VARIABLE_NAME = `${exports.API_CREDENTIALS_NAMESPACE}password`;
+function generateVariablesSummaryForImport(variableSources) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const { environment, scenario, url, credentials, plan, flow, journeyRun, previousFlowVariables, } = variableSources;
+    const summary = {
+        dataDriven: {},
+        effective: {},
+        environment: {},
+        flow: {},
+        journey: {},
+        parameters: {},
+    };
+    const environmentVariables = (environment === null || environment === void 0 ? void 0 : environment.variables) || {};
+    Object.keys(environmentVariables).forEach((key) => (summary.environment[removeUserNamespace(key)] =
+        environmentVariables[key]));
+    const planParameters = extractValueParameters(plan === null || plan === void 0 ? void 0 : plan.parameters);
+    planParameters.forEach((parameter) => (summary.parameters[removeUserNamespace(parameter.name)] =
+        parameter.value));
+    const journeyParameters = extractValueParameters(journeyRun &&
+        (plan === null || plan === void 0 ? void 0 : plan.execution_stages) &&
+        ((_c = (_b = (_a = plan.execution_stages[journeyRun.stage_index]) === null || _a === void 0 ? void 0 : _a.journeys) === null || _b === void 0 ? void 0 : _b.find((journey) => journey.journey_id)) === null || _c === void 0 ? void 0 : _c.parameters));
+    journeyParameters.forEach((parameter) => (summary.parameters[removeUserNamespace(parameter.name)] =
+        parameter.value));
+    const journeyInputs = ((_d = journeyRun === null || journeyRun === void 0 ? void 0 : journeyRun.journey_parameters) === null || _d === void 0 ? void 0 : _d.imported_variables) || {};
+    Object.keys(journeyInputs).forEach((key) => (summary.journey[removeUserNamespace(key)] = journeyInputs[key]));
+    const ddtVariables = ((_f = (_e = journeyRun === null || journeyRun === void 0 ? void 0 : journeyRun.journey_parameters) === null || _e === void 0 ? void 0 : _e.user_variables) === null || _f === void 0 ? void 0 : _f.row) ||
+        (scenario === null || scenario === void 0 ? void 0 : scenario.variables) ||
+        [];
+    ddtVariables.forEach((variable) => (summary.dataDriven[removeUserNamespace(variable.name)] =
+        variable.value));
+    const precedence = [
+        summary.environment,
+        summary.parameters,
+        summary.journey,
+        summary.dataDriven,
+    ];
+    precedence.forEach((variables) => Object.keys(variables).forEach((name) => (summary.effective[name] = variables[name])));
+    if (flow === null || flow === void 0 ? void 0 : flow.parameters) {
+        flow.parameters.forEach((parameter) => {
+            const parameterName = removePrefix(parameter.name, exports.FLOW_NAMESPACE);
+            summary.flow[parameterName] = parameter.default_value;
+            if (!summary.effective[parameterName]) {
+                summary.effective[parameterName] = parameter.default_value;
+            }
+        });
+    }
+    const exportedVariables = previousFlowVariables || {};
+    Object.keys(exportedVariables).forEach((key) => {
+        summary.dataDriven[key] = exportedVariables[key];
+        summary.effective[key] = exportedVariables[key];
+    });
+    if (url) {
+        summary.effective[exports.API_URL_VARIABLE_NAME] = url;
+    }
+    if (credentials) {
+        summary.effective[exports.API_CREDENTIALS_USERNAME_VARIABLE_NAME] =
+            (_g = credentials.properties) === null || _g === void 0 ? void 0 : _g.username;
+        summary.effective[exports.API_CREDENTIALS_PASSWORD_VARIABLE_NAME] =
+            (_h = credentials.properties) === null || _h === void 0 ? void 0 : _h.password;
+    }
+    return summary;
+}
+exports.generateVariablesSummaryForImport = generateVariablesSummaryForImport;
+function generateVariablesSummaryForExport(testContext, plan, flow, journeyRun, exportedVariables) {
+    return normalizeVariablesSummaryForExport(generateVariablesSummaryForImport({
+        environment: testContext.environment,
+        url: testContext.url,
+        credentials: testContext.credentials,
+        scenario: testContext.getScenario(),
+        plan,
+        flow,
+        journeyRun,
+        previousFlowVariables: exportedVariables,
+    }));
+}
+exports.generateVariablesSummaryForExport = generateVariablesSummaryForExport;
+function normalizeVariablesSummaryForExport(summary) {
+    return {
+        dataDriven: addUserNamespaceToVariableNames(sanitizeVariables(summary.dataDriven)),
+        effective: sanitizeVariables(summary.effective),
+        environment: addUserNamespaceToVariableNames(sanitizeVariables(summary.environment)),
+        flow: addPrefixToVariableNames(sanitizeVariables(summary.flow), exports.FLOW_NAMESPACE),
+        journey: addUserNamespaceToVariableNames(sanitizeVariables(summary.journey)),
+        parameters: addUserNamespaceToVariableNames(sanitizeVariables(summary.parameters)),
+    };
+}
+function sanitizeVariables(variables) {
+    const sanitizedVariables = {};
+    Object.keys(variables)
+        .filter((name) => (0, domUtil_1.isValidUserVariableName)(name))
+        .forEach((name) => (sanitizedVariables[name] = variables[name]));
+    return sanitizedVariables;
+}
+function addUserNamespaceToVariableNames(variables) {
+    return addPrefixToVariableNames(variables, exports.USER_NAMESPACE);
+}
+function addPrefixToVariableNames(variables, prefix) {
+    return mapVariables(variables, (variable) => ({
+        name: addPrefix(variable.name, prefix),
+        value: variable.value,
+    }));
+}
+function mapVariables(variables, mapper) {
+    const mappedVariables = {};
+    Object.keys(variables)
+        .map((name) => mapper({ name, value: variables[name] }))
+        .forEach((variable) => (mappedVariables[variable.name] = variable.value));
+    return mappedVariables;
+}
+function extractValueParameters(parameters) {
+    if (!parameters) {
+        return [];
+    }
+    return parameters.filter((parameter) => { var _a; return ((_a = parameter.type) === null || _a === void 0 ? void 0 : _a.toString()) === 'value'; });
+}
+function removeUserNamespace(variableName) {
+    return removePrefix(variableName, exports.USER_NAMESPACE);
+}
+function removePrefix(variableName, prefix) {
+    if (variableName.startsWith(prefix)) {
+        return variableName.substring(prefix.length);
+    }
+    return variableName;
+}
+function addUserNamespace(variableName) {
+    return addPrefix(variableName, exports.USER_NAMESPACE);
+}
+exports.addUserNamespace = addUserNamespace;
+function addPrefix(variableName, prefix) {
+    if (variableName.startsWith(prefix)) {
+        return variableName;
+    }
+    return `${prefix}${variableName}`;
+}
+function findUsedVariables(collection, variableNames) {
+    const collectionSubset = {
+        auth: collection.auth,
+        item: collection.item,
+        event: collection.event,
+    };
+    const collectionAsJson = JSON.stringify(collectionSubset);
+    return variableNames.filter((variableName) => collectionAsJson.includes(variableName));
+}
+exports.findUsedVariables = findUsedVariables;

package/core/execution/VariablesSummary.js

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

package/core/execution/basic-types.js

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

package/core/execution/newman-types.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BodyMode = exports.MablSupportedPostmanAuthTypes = exports.SUPPORTED_COLLECTION_SCHEMA = exports.AssertionType = exports.AssertionTarget = void 0;
+var AssertionTarget;
+(function (AssertionTarget) {
+    AssertionTarget["Header"] = "Header";
+    AssertionTarget["JSONBody"] = "JSONBody";
+    AssertionTarget["Size"] = "Size";
+    AssertionTarget["Status"] = "Status";
+})(AssertionTarget || (exports.AssertionTarget = AssertionTarget = {}));
+var AssertionType;
+(function (AssertionType) {
+    AssertionType["Contains"] = "Contains";
+    AssertionType["DoesNotContain"] = "DoesNotContain";
+    AssertionType["EndsWith"] = "EndsWith";
+    AssertionType["Equals"] = "Equals";
+    AssertionType["GreaterThan"] = "GreaterThan";
+    AssertionType["GreaterThanOrEqualTo"] = "GreaterThanOrEqualTo";
+    AssertionType["LessThan"] = "LessThan";
+    AssertionType["LessThanOrEqualTo"] = "LessThanOrEqualTo";
+    AssertionType["MatchesRegExp"] = "MatchesRegExp";
+    AssertionType["NotEquals"] = "NotEquals";
+    AssertionType["NotPresent"] = "NotPresent";
+    AssertionType["Present"] = "Present";
+    AssertionType["StartsWith"] = "StartsWith";
+})(AssertionType || (exports.AssertionType = AssertionType = {}));
+exports.SUPPORTED_COLLECTION_SCHEMA = 'https://schema.getpostman.com/json/collection/v2.1.0/collection.json';
+exports.MablSupportedPostmanAuthTypes = [
+    'apikey',
+    'basic',
+    'bearer',
+    'oauth1',
+];
+var BodyMode;
+(function (BodyMode) {
+    BodyMode["file"] = "file";
+    BodyMode["formdata"] = "formdata";
+    BodyMode["graphql"] = "graphql";
+    BodyMode["none"] = "none";
+    BodyMode["raw"] = "raw";
+    BodyMode["urlencoded"] = "urlencoded";
+})(BodyMode || (exports.BodyMode = BodyMode = {}));

package/core/messaging/actions/MobileTrainingActions.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileTrainingActionsEventEmitter = exports.MobileTrainingMessageType = void 0;
+const messaging_1 = require("../messaging");
+var MobileTrainingMessageType;
+(function (MobileTrainingMessageType) {
+    MobileTrainingMessageType["foundElement"] = "mobileFoundElement";
+})(MobileTrainingMessageType || (exports.MobileTrainingMessageType = MobileTrainingMessageType = {}));
+class MobileTrainingActionsEventEmitter {
+    static emitFoundElementInfo(foundElement, isACandidateElement) {
+        return messaging_1.mablEventEmitter.dispatch(new messaging_1.MablCoreAction(MobileTrainingMessageType.foundElement, {
+            boundingBox: foundElement.boundingBox,
+            isACandidateElement,
+        }));
+    }
+}
+exports.MobileTrainingActionsEventEmitter = MobileTrainingActionsEventEmitter;

package/core/messaging/actions/pdfActions.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PdfEventEmitter = exports.PdfActionMessageType = void 0;
+const messaging_1 = require("../messaging");
+var PdfActionMessageType;
+(function (PdfActionMessageType) {
+    PdfActionMessageType["EmbeddedPdfDownloading"] = "EMBEDDED_PDF_DOWNLOADING";
+    PdfActionMessageType["EmbeddedPdfViewerReady"] = "EMBEDDED_PDF_VIEWER_READY";
+})(PdfActionMessageType || (exports.PdfActionMessageType = PdfActionMessageType = {}));
+class PdfEventEmitter {
+    static embeddedPdfDownloading(frameId, pdfFileName, pdfUrl) {
+        PdfEventEmitter.eventEmitter.dispatch(new messaging_1.MablCoreAction(PdfActionMessageType.EmbeddedPdfDownloading, {
+            frameId,
+            pdfFileName,
+            pdfUrl,
+        }));
+    }
+    static embeddedPdfViewerReady(frameId, pdfFileName, pdfUrl) {
+        PdfEventEmitter.eventEmitter.dispatch(new messaging_1.MablCoreAction(PdfActionMessageType.EmbeddedPdfViewerReady, {
+            frameId,
+            pdfFileName,
+            pdfUrl,
+        }));
+    }
+}
+exports.PdfEventEmitter = PdfEventEmitter;
+PdfEventEmitter.eventEmitter = messaging_1.mablEventEmitter;

package/core/messaging/actions/runnerActions.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerActionEventEmitter = exports.RunnerActionMessageTypes = void 0;
+const messaging_1 = require("../messaging");
+var RunnerActionMessageTypes;
+(function (RunnerActionMessageTypes) {
+    RunnerActionMessageTypes["RUNNER_STOP"] = "RUNNER_STOP";
+    RunnerActionMessageTypes["RUNNER_TERMINATE"] = "RUNNER_TERMINATE";
+})(RunnerActionMessageTypes || (exports.RunnerActionMessageTypes = RunnerActionMessageTypes = {}));
+class RunnerActionEventEmitter {
+    static stopRunningTest(eventEmitter) {
+        (0, messaging_1.getEmitter)(eventEmitter).sendToProcess(new messaging_1.MablCoreProcessAction(RunnerActionMessageTypes.RUNNER_STOP, {}));
+    }
+    static killRunningTest(eventEmitter) {
+        (0, messaging_1.getEmitter)(eventEmitter).sendToProcess(new messaging_1.MablCoreProcessAction(RunnerActionMessageTypes.RUNNER_TERMINATE, {}));
+    }
+}
+exports.RunnerActionEventEmitter = RunnerActionEventEmitter;

package/core/messaging/actions/trainingSessionActions.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrainingEventEmitter = exports.TrainingSessionMessageType = void 0;
+const messaging_1 = require("../messaging");
+var TrainingSessionMessageType;
+(function (TrainingSessionMessageType) {
+    TrainingSessionMessageType["closed"] = "TRAINING_SESSION_CLOSED";
+    TrainingSessionMessageType["error"] = "TRAINING_SESSION_ERROR";
+    TrainingSessionMessageType["initializing"] = "TRAINING_SESSION_INITIALIZING";
+    TrainingSessionMessageType["saved"] = "TRAINING_SESSION_SAVED";
+    TrainingSessionMessageType["started"] = "TRAINING_SESSION_STARTED";
+})(TrainingSessionMessageType || (exports.TrainingSessionMessageType = TrainingSessionMessageType = {}));
+class TrainingEventEmitter {
+    static sessionInitializing() {
+        messaging_1.mablEventEmitter.dispatch(new messaging_1.MablCoreAction(TrainingSessionMessageType.initializing, {}));
+    }
+    static sessionStarted() {
+        messaging_1.mablEventEmitter.dispatch(new messaging_1.MablCoreAction(TrainingSessionMessageType.started, {}));
+    }
+    static sessionError(errorMessage) {
+        messaging_1.mablEventEmitter.dispatch(new messaging_1.MablCoreAction(TrainingSessionMessageType.error, {
+            errorMessage,
+        }));
+    }
+    static sessionSaved(testId, testInvariantId, branchName, planId) {
+        const actionPayload = {
+            testId,
+            testInvariantId,
+            planId,
+            branchName,
+        };
+        messaging_1.mablEventEmitter.dispatch(new messaging_1.MablCoreAction(TrainingSessionMessageType.saved, actionPayload));
+    }
+    static sessionClosed() {
+        messaging_1.mablEventEmitter.dispatch(new messaging_1.MablCoreAction(TrainingSessionMessageType.closed, {}));
+    }
+}
+exports.TrainingEventEmitter = TrainingEventEmitter;

package/core/messaging/logLineMessaging.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerConsoleLoggerForOutput = exports.LogLineColor = void 0;
+const messaging_1 = require("./messaging");
+const moment = require("moment");
+const chalk_1 = __importDefault(require("chalk"));
+const env_1 = require("../../env/env");
+const loggingProvider_1 = require("../../providers/logging/loggingProvider");
+var LogLineColor;
+(function (LogLineColor) {
+    LogLineColor["cyan"] = "cyan";
+    LogLineColor["magenta"] = "magenta";
+    LogLineColor["red"] = "red";
+    LogLineColor["white"] = "white";
+    LogLineColor["yellow"] = "yellow";
+})(LogLineColor || (exports.LogLineColor = LogLineColor = {}));
+function registerConsoleLoggerForOutput(eventEmitter) {
+    eventEmitter
+        .getOutputEventChannel()
+        .on(messaging_1.EventChannelMessageType.outputLogLine, (line, timestamp, color, metadata) => {
+        var _a;
+        const stepNumberPrefix = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.stepNumberPrefix) !== null && _a !== void 0 ? _a : '';
+        const lineWithPrefix = stepNumberPrefix + line;
+        const formatted = color ? chalk_1.default[color](lineWithPrefix) : lineWithPrefix;
+        if ((metadata === null || metadata === void 0 ? void 0 : metadata.shouldOutputInConsole) === false) {
+            return;
+        }
+        if (timestamp) {
+            let formattedTimestamp = '';
+            formattedTimestamp = `${moment
+                .unix(timestamp / 1000)
+                .format('LTS')} - `;
+            loggingProvider_1.logger.info(`${chalk_1.default.yellow(formattedTimestamp)}${formatted}`);
+        }
+        else {
+            loggingProvider_1.logger.info(formatted);
+        }
+    });
+    if (env_1.ENV === 'local' && env_1.DEBUG_EVENT_EMITTER) {
+        eventEmitter
+            .getOutputEventChannel()
+            .on(messaging_1.EventChannelMessageType.coreAction, (action) => {
+            loggingProvider_1.logger.info(action);
+        });
+    }
+}
+exports.registerConsoleLoggerForOutput = registerConsoleLoggerForOutput;

package/core/messaging/messaging.js

@@ -0,0 +1,130 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAssertResultMessage = exports.createAssertFailureMessage = exports.getDefaultLogMetadataForInfo = exports.MablCoreProcessAction = exports.MablCoreAction = exports.ObservationErrorSeverity = exports.ObservationErrorCode = exports.ExecutionPhase = exports.EventChannelMessageType = exports.getEmitter = exports.mablEventEmitter = exports.MablCoreEventEmitter = void 0;
+const events_1 = require("events");
+const loggingProvider_1 = require("../../providers/logging/loggingProvider");
+const pureUtil_1 = require("../../util/pureUtil");
+const NO_ID_PLACEHOLDER = 'NO_ID_PROVIDED';
+class MablCoreEventEmitter {
+    constructor(debug) {
+        this.messageIndex = -1;
+        this.outputEventChannel = new events_1.EventEmitter();
+        this.inputEventChannel = new events_1.EventEmitter();
+        this.debugOutputOn = debug !== null && debug !== void 0 ? debug : false;
+    }
+    getOutputEventChannel() {
+        return this.outputEventChannel;
+    }
+    getInputEventChannel() {
+        return this.inputEventChannel;
+    }
+    getNextMessageIndex() {
+        this.messageIndex += 1;
+        return this.messageIndex;
+    }
+    dispatch(action, metadata) {
+        this.outputEventChannel.emit(EventChannelMessageType.coreAction, action, metadata);
+    }
+    sendToProcess(action) {
+        this.inputEventChannel.emit(EventChannelMessageType.coreProcessAction, action);
+    }
+    log(line, timestamp, color, metadata) {
+        this.outputEventChannel.emit(EventChannelMessageType.outputLogLine, line, timestamp, color, metadata);
+    }
+    debug(line, timestamp, color, metadata) {
+        const effectiveMetadata = metadata !== null && metadata !== void 0 ? metadata : {
+            logLevel: loggingProvider_1.LogLevel.Debug,
+            timestamp: Date.now(),
+        };
+        this.log(line, timestamp, color, {
+            ...effectiveMetadata,
+            shouldOutputInConsole: this.debugOutputOn,
+        });
+    }
+}
+exports.MablCoreEventEmitter = MablCoreEventEmitter;
+global.mablEventEmitter = (_a = global.mablEventEmitter) !== null && _a !== void 0 ? _a : new MablCoreEventEmitter();
+exports.mablEventEmitter = global.mablEventEmitter;
+function getEmitter(eventEmitter) {
+    return eventEmitter !== null && eventEmitter !== void 0 ? eventEmitter : exports.mablEventEmitter;
+}
+exports.getEmitter = getEmitter;
+var EventChannelMessageType;
+(function (EventChannelMessageType) {
+    EventChannelMessageType["coreAction"] = "coreAction";
+    EventChannelMessageType["coreProcessAction"] = "coreProcessAction";
+    EventChannelMessageType["outputLogLine"] = "outputLogLine";
+})(EventChannelMessageType || (exports.EventChannelMessageType = EventChannelMessageType = {}));
+var ExecutionPhase;
+(function (ExecutionPhase) {
+    ExecutionPhase["AFTER_ACTION"] = "AFTER_ACTION";
+    ExecutionPhase["AFTER_DEFERRED_ACTION"] = "AFTER_DEFERRED_ACTION";
+    ExecutionPhase["AFTER_FLOW"] = "AFTER_FLOW";
+    ExecutionPhase["AFTER_TEST"] = "AFTER_TEST";
+    ExecutionPhase["ASYNC"] = "ASYNC";
+    ExecutionPhase["BEFORE_ACTION"] = "BEFORE_ACTION";
+    ExecutionPhase["BEFORE_FLOW"] = "BEFORE_FLOW";
+    ExecutionPhase["BEFORE_TEST"] = "BEFORE_TEST";
+    ExecutionPhase["DURING_ACTION"] = "DURING_ACTION";
+    ExecutionPhase["SKIP_ACTION"] = "SKIP_ACTION";
+})(ExecutionPhase || (exports.ExecutionPhase = ExecutionPhase = {}));
+var ObservationErrorCode;
+(function (ObservationErrorCode) {
+    ObservationErrorCode["ILLEGAL_URL_ERROR"] = "ILLEGAL_URL_ERROR";
+    ObservationErrorCode["PAGE_LOAD_FAILURE"] = "PAGE_LOAD_FAILURE";
+})(ObservationErrorCode || (exports.ObservationErrorCode = ObservationErrorCode = {}));
+var ObservationErrorSeverity;
+(function (ObservationErrorSeverity) {
+    ObservationErrorSeverity["ERROR"] = "ERROR";
+    ObservationErrorSeverity["WARN"] = "WARN";
+})(ObservationErrorSeverity || (exports.ObservationErrorSeverity = ObservationErrorSeverity = {}));
+class MablCoreAction {
+    constructor(type, payload, timestamp = Date.now()) {
+        this.type = type;
+        this.payload = payload;
+        this.timestamp = timestamp;
+    }
+}
+exports.MablCoreAction = MablCoreAction;
+class MablCoreProcessAction extends MablCoreAction {
+}
+exports.MablCoreProcessAction = MablCoreProcessAction;
+function getDefaultLogMetadataForInfo(testId, testInvariantId) {
+    return {
+        executionIndex: {
+            testId: testId !== null && testId !== void 0 ? testId : NO_ID_PLACEHOLDER,
+            testInvariantId: testInvariantId !== null && testInvariantId !== void 0 ? testInvariantId : NO_ID_PLACEHOLDER,
+        },
+        executionPhase: ExecutionPhase.BEFORE_TEST,
+        logLevel: loggingProvider_1.LogLevel.Info,
+        timestamp: Date.now(),
+    };
+}
+exports.getDefaultLogMetadataForInfo = getDefaultLogMetadataForInfo;
+function createAssertFailureMessage(assertFailure) {
+    if (assertFailure) {
+        const { reason, expected, found, onFailure, shortReason } = assertFailure;
+        return {
+            reason,
+            shortReason,
+            expected: (0, pureUtil_1.stringifyIfPresent)(expected),
+            found: (0, pureUtil_1.stringifyIfPresent)(found),
+            onFailure,
+        };
+    }
+    return;
+}
+exports.createAssertFailureMessage = createAssertFailureMessage;
+function createAssertResultMessage(assertResult) {
+    if (assertResult) {
+        const { success, assertionCriteria } = assertResult;
+        return {
+            success,
+            assertionCriteria,
+            ...createAssertFailureMessage(assertResult),
+        };
+    }
+    return;
+}
+exports.createAssertResultMessage = createAssertResultMessage;

package/core/messaging/pageMessaging.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEB_PERFORMANCE_METRIC_DETECTED_MESSAGE_TYPE = exports.EmbeddedPdfDetectionEvents = void 0;
+var EmbeddedPdfDetectionEvents;
+(function (EmbeddedPdfDetectionEvents) {
+    EmbeddedPdfDetectionEvents["EmbeddedPdfDetected"] = "EMBEDDED_PDF_DETECTED";
+    EmbeddedPdfDetectionEvents["EmbeddedPdfMarked"] = "EMBEDDED_PDF_MARKED";
+})(EmbeddedPdfDetectionEvents || (exports.EmbeddedPdfDetectionEvents = EmbeddedPdfDetectionEvents = {}));
+exports.WEB_PERFORMANCE_METRIC_DETECTED_MESSAGE_TYPE = 'WEB_PERFORMANCE_METRIC_DETECTED';

package/core/trainer/openUtils.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.logSessionStarted = exports.openUrlInDesktopApp = void 0;
+const open_1 = __importDefault(require("open"));
+const env_1 = require("../../env/env");
+const timers_1 = require("timers");
+const messaging_1 = require("../messaging/messaging");
+const chalk_1 = __importDefault(require("chalk"));
+const encodingUtil_1 = require("../../util/encodingUtil");
+async function openUrlInDesktopApp(url, trainingSessionOptions) {
+    const params = (0, encodingUtil_1.encodeTestConfigAsParamsForParsedUrlProtocol)(trainingSessionOptions, encodingUtil_1.b64EncodeUnicodeInNode);
+    const childProcess = await (0, open_1.default)(`${env_1.ELECTRON_PROTOCOL}://${url}/${params}`);
+    let childProcessExited = false;
+    const keepAliveUntilExited = () => {
+        if (!childProcessExited) {
+            (0, timers_1.setTimeout)(keepAliveUntilExited, 1000);
+        }
+    };
+    keepAliveUntilExited();
+    const exitCode = await new Promise((resolve) => {
+        childProcess.on('error', () => {
+            childProcessExited = true;
+            resolve(1);
+        });
+        childProcess.on('exit', function () {
+            childProcessExited = true;
+            resolve(childProcess.exitCode);
+        });
+    });
+    if (exitCode === 0) {
+        logSessionStarted();
+    }
+    else {
+        logInstallDesktopApp();
+    }
+}
+exports.openUrlInDesktopApp = openUrlInDesktopApp;
+function logSessionStarted() {
+    messaging_1.mablEventEmitter.log(chalk_1.default.yellowBright('Session started in the desktop app'));
+}
+exports.logSessionStarted = logSessionStarted;
+function logInstallDesktopApp() {
+    messaging_1.mablEventEmitter.log(chalk_1.default.red(`\nFailed to launch mabl desktop app!`, chalk_1.default.cyan(`\nPlease check your installation or download and install it from`), chalk_1.default.magenta('https://www.mabl.com/desktop-app')));
+}