@mablhq/mabl-cli 1.48.41 → 1.48.47

package/api/basicApiClient.js

@@ -181,9 +181,15 @@ class BasicApiClient {
         BasicApiClient.checkResponseStatusCode(response);
         return response.data;
     }
-    async makePatchRequest(path, requestBody, ifMatch) {
+    async makePatchRequest(path, requestBody, ifMatch, requestConfig) {
+        return this.patchRequest(path, requestBody, ifMatch, this.getNonRetryableRequestConfig(requestConfig));
+    }
+    async makePatchRequestWithRetries(path, requestBody, ifMatch, config) {
+        return this.retryWrappedRequest(`makePatchRequestWithRetries('${path}')`, () => this.patchRequest(path, requestBody, ifMatch, this.getRetryableRequestConfig(config)), config);
+    }
+    async patchRequest(path, requestBody, ifMatch, config) {
         const extraConfig = ifMatch ? { headers: { 'If-Match': ifMatch } } : {};
-        const response = await this.debugRequest('PATCH', path, () => this.httpClient.patch(path, requestBody, extraConfig));
+        const response = await this.debugRequest('PATCH', path, () => this.httpClient.patch(path, requestBody, { ...config, ...extraConfig }));
         BasicApiClient.checkResponseStatusCode(response);
         return response.data;
     }

package/api/mablApiClient.js

@@ -31,10 +31,6 @@ const cliConfigProvider_1 = require("../providers/cliConfigProvider");
 const basicApiClient_1 = require("./basicApiClient");
 const queryString = __importStar(require("query-string"));
 const featureSet_1 = require("./featureSet");
-const DEPLOYMENT_EVENT_RETRY_CONFIG = {
-    requestTimeoutMillis: 0,
-    maxRetryTimeMillis: 1000 * 60 * 60,
-};
 class MablApiClient extends basicApiClient_1.BasicApiClient {
     constructor(options) {
         var _a;
@@ -258,7 +254,7 @@ class MablApiClient extends basicApiClient_1.BasicApiClient {
     }
     async getDeploymentResults(deploymentEventId) {
         try {
-            return await this.makeGetRequest(`${this.baseApiUrl}/execution/result/event/${deploymentEventId}`, DEPLOYMENT_EVENT_RETRY_CONFIG);
+            return await this.makeGetRequest(`${this.baseApiUrl}/execution/result/event/${deploymentEventId}`);
         }
         catch (error) {
             throw toApiError(`Failed to get deployment results`, error);
@@ -575,7 +571,7 @@ class MablApiClient extends basicApiClient_1.BasicApiClient {
     async postDeploymentEvent(options) {
         try {
             const requestBody = this.buildDeploymentRequestBody(options);
-            return await this.makePostRequestWithRetries(`${this.baseApiUrl}/events/deployment/`, requestBody, DEPLOYMENT_EVENT_RETRY_CONFIG);
+            return await this.makePostRequestWithRetries(`${this.baseApiUrl}/events/deployment/`, requestBody);
         }
         catch (error) {
             throw toApiError(`Failed to create deployment`, error);
@@ -745,9 +741,11 @@ class MablApiClient extends basicApiClient_1.BasicApiClient {
             throw toApiError(`Failed to get journey run info`, error);
         }
     }
-    async updateJourneyRun(journeyRunId, journeyRunUpdate, ifMatch) {
+    async updateJourneyRun(journeyRunId, journeyRunUpdate, ifMatch, retry) {
         try {
-            const response = await this.makePatchRequest(`${this.baseApiUrl}/journeyRuns/${journeyRunId}`, journeyRunUpdate, ifMatch);
+            const response = retry
+                ? await this.makePatchRequestWithRetries(`${this.baseApiUrl}/journeyRuns/${journeyRunId}`, journeyRunUpdate, ifMatch)
+                : await this.makePatchRequest(`${this.baseApiUrl}/journeyRuns/${journeyRunId}`, journeyRunUpdate, ifMatch);
             return response;
         }
         catch (error) {

package/api/mablApiClientFactory.js

@@ -19,8 +19,9 @@ class MablApiClientFactory {
         }
         return MablApiClientFactory.createApiClient();
     }
-    static createApiClientFromApiKey(apiKey) {
+    static createApiClientFromApiKey(apiKey, apiUrl) {
         return MablApiClientFactory.createApiClient({
+            apiUrl,
             authType: types_1.AuthType.ApiKey,
             token: apiKey,
         });

package/browserLauncher/playwrightBrowserLauncher/playwrightDom.js

@@ -246,6 +246,10 @@ class PlaywrightElementHandle extends PlaywrightJsHandle {
         const result = await this.element.evaluate((el, attributeName) => el.getAttribute(attributeName), attributeName);
         return (0, pureUtil_1.isNullish)(result) ? undefined : result;
     }
+    async getCSSProperty(propertyName) {
+        const result = await this.element.evaluate((el, propertyName) => globalThis.getComputedStyle(el).getPropertyValue(propertyName), propertyName);
+        return (0, pureUtil_1.isNullish)(result) ? undefined : result;
+    }
     async getElementText() {
         const innerText = await this.getInnerText();
         return innerText ? innerText : this.getSlotText();

package/{mablscript/steps → codeGenerators/seleniumConfigGenerators}/SeleniumIdeStep.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateIdForSeleniumEntity = exports.buildSeleniumIdeStep = void 0;
+exports.substituteSeleniumVariable = exports.generateIdForSeleniumEntity = exports.buildSeleniumIdeStep = void 0;
+const MablSymbol_1 = require("../../mablscript/MablSymbol");
 const crypto = require('crypto');
 function buildSeleniumIdeStep(commandName, mablscriptStep) {
     let description = '';
@@ -30,3 +31,10 @@ function generateIdForSeleniumEntity(genValue) {
         .digest('hex');
 }
 exports.generateIdForSeleniumEntity = generateIdForSeleniumEntity;
+function substituteSeleniumVariable(argument) {
+    if (argument instanceof MablSymbol_1.MablSymbol) {
+        return '${' + argument.name + '}';
+    }
+    return argument.replace(/{{@?([^{}]+)}}/g, (_match, p1) => '${' + p1 + '}');
+}
+exports.substituteSeleniumVariable = substituteSeleniumVariable;

package/{configGenerators → codeGenerators/seleniumConfigGenerators}/flowConfigGenerator.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowConfig = void 0;
-const importer_1 = require("../mablscript/importer");
+const importer_1 = require("../../mablscript/importer");
 class FlowConfig {
     constructor(flow, includeLocatorInfo) {
         this.flow = flow;

package/{configGenerators → codeGenerators/seleniumConfigGenerators}/selIdeGenerator.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SelIdeConfig = void 0;
-const SeleniumIdeStep_1 = require("../mablscript/steps/SeleniumIdeStep");
-const importer_1 = require("../mablscript/importer");
+exports.seleniumIdeTheLoadedSteps = exports.SelIdeConfig = void 0;
+const SeleniumIdeStep_1 = require("./SeleniumIdeStep");
+const importer_1 = require("../../mablscript/importer");
+const stepConverters_1 = require("./stepConverters");
 class SelIdeConfig {
     constructor(journey, flows) {
         this.journey = journey;
@@ -19,7 +20,7 @@ class SelIdeConfig {
             const loadedSteps = (0, importer_1.parseMablScriptIntoSteps)(flow);
             steps = steps.concat(loadedSteps);
         });
-        selIdeTest.commands = (0, importer_1.seleniumIdeTheLoadedSteps)(steps);
+        selIdeTest.commands = seleniumIdeTheLoadedSteps(steps);
         const storeDefaultUrl = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('store');
         if (this.journey.url) {
             storeDefaultUrl.target = this.journey.url;
@@ -45,3 +46,18 @@ class SelIdeConfig {
     }
 }
 exports.SelIdeConfig = SelIdeConfig;
+function seleniumIdeTheLoadedSteps(translatedSteps) {
+    const selIdeSteps = translatedSteps.map((step, stepIndex) => {
+        const codeGenerator = stepConverters_1.stepGenerators.get(step.constructor.name);
+        if (codeGenerator) {
+            return codeGenerator(step, stepIndex);
+        }
+        const selIdeEcho = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('echo');
+        const unSupportedStepMessage = `[${step.getStepName()}] Step is not supported for Selenium IDE export`;
+        selIdeEcho.comment = unSupportedStepMessage;
+        selIdeEcho.target = unSupportedStepMessage;
+        return [selIdeEcho];
+    });
+    return [].concat.apply([], selIdeSteps);
+}
+exports.seleniumIdeTheLoadedSteps = seleniumIdeTheLoadedSteps;

package/codeGenerators/seleniumConfigGenerators/stepConverters.js

@@ -0,0 +1,380 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enterTextStepToSeleniumSteps = exports.createVariableStepToSeleniumSteps = exports.clickStepToSeleniumSteps = exports.echoStepToSeleniumSteps = exports.hoverStepToSeleniumSteps = exports.stepGenerators = void 0;
+const domUtil_1 = require("../../domUtil");
+const FindAction_1 = require("../../mablscript/actions/FindAction");
+const GetUrlAction_1 = require("../../mablscript/actions/GetUrlAction");
+const GetVariableValue_1 = require("../../mablscript/actions/GetVariableValue");
+const AssertStep_1 = require("../../mablscript/steps/AssertStep");
+const ClickStep_1 = require("../../mablscript/steps/ClickStep");
+const CreateVariableStep_1 = require("../../mablscript/steps/CreateVariableStep");
+const DoubleClickStep_1 = require("../../mablscript/steps/DoubleClickStep");
+const EchoStep_1 = require("../../mablscript/steps/EchoStep");
+const EnterTextStep_1 = require("../../mablscript/steps/EnterTextStep");
+const HoverStep_1 = require("../../mablscript/steps/HoverStep");
+const NavigateStep_1 = require("../../mablscript/steps/NavigateStep");
+const RightClickStep_1 = require("../../mablscript/steps/RightClickStep");
+const SendKeyStep_1 = require("../../mablscript/steps/SendKeyStep");
+const SetViewportStep_1 = require("../../mablscript/steps/SetViewportStep");
+const SwitchContextStep_1 = require("../../mablscript/steps/SwitchContextStep");
+const VisitUrlStep_1 = require("../../mablscript/steps/VisitUrlStep");
+const WaitStep_1 = require("../../mablscript/steps/WaitStep");
+const CreateVariableStepDescriptor_1 = require("../../mablscript/types/CreateVariableStepDescriptor");
+const GetCurrentLocationDescriptor_1 = require("../../mablscript/types/GetCurrentLocationDescriptor");
+const GetVariableDescriptor_1 = require("../../mablscript/types/GetVariableDescriptor");
+const SwitchContextStepDescriptor_1 = require("../../mablscript/types/SwitchContextStepDescriptor");
+const SeleniumIdeStep_1 = require("./SeleniumIdeStep");
+exports.stepGenerators = new Map();
+exports.stepGenerators.set(AssertStep_1.AssertStep.name, assertStepToSeleniumSteps);
+exports.stepGenerators.set(ClickStep_1.ClickStep.name, clickStepToSeleniumSteps);
+exports.stepGenerators.set(CreateVariableStep_1.CreateVariableStep.name, createVariableStepToSeleniumSteps);
+exports.stepGenerators.set(DoubleClickStep_1.DoubleClickStep.name, doubleClickStepToSeleniumSteps);
+exports.stepGenerators.set(EchoStep_1.EchoStep.name, echoStepToSeleniumSteps);
+exports.stepGenerators.set(EnterTextStep_1.EnterTextStep.name, enterTextStepToSeleniumSteps);
+exports.stepGenerators.set(HoverStep_1.HoverStep.name, hoverStepToSeleniumSteps);
+exports.stepGenerators.set(NavigateStep_1.NavigateStep.name, navigateStepToSeleniumSteps);
+exports.stepGenerators.set(RightClickStep_1.RightClickStep.name, rightClickStepToSeleniumSteps);
+exports.stepGenerators.set(SendKeyStep_1.SendKeyStep.name, sendKeyStepToSeleniumSteps);
+exports.stepGenerators.set(SetViewportStep_1.SetViewportStep.name, setViewportStepToSeleniumSteps);
+exports.stepGenerators.set(SwitchContextStep_1.SwitchContextStep.name, switchContextStepToSeleniumSteps);
+exports.stepGenerators.set(VisitUrlStep_1.VisitUrlStep.name, visitUrlStepToSeleniumSteps);
+exports.stepGenerators.set(WaitStep_1.WaitStep.name, waitStepToSeleniumSteps);
+function assertStepToSeleniumSteps(baseStep, stepIndex) {
+    var _a;
+    const step = baseStep;
+    if (!step) {
+        throw new Error('Expected an assert step');
+    }
+    const find = step.primaryAction.toDescriptor();
+    if (!(0, GetCurrentLocationDescriptor_1.isGetCurrentLocationDescriptor)(find) &&
+        !(0, GetVariableDescriptor_1.isGetVariableDescriptor)(find) &&
+        (find.findType === domUtil_1.FindType.FIND_EMAIL ||
+            find.findType === domUtil_1.FindType.FIND_COOKIE)) {
+        return [unsupportedSelIdeExportStep(step)];
+    }
+    if (step.assertionType === 'present') {
+        if (step.primaryAction instanceof GetUrlAction_1.GetUrlAction) {
+            throw new Error('Invalid state. You cannot assert presence against URL properties.');
+        }
+        if (step.primaryAction instanceof GetVariableValue_1.GetVariableValue) {
+            throw new Error('Invalid state. You cannot assert presence against variable properties.');
+        }
+        const assertPresentStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('assertElementPresent', step);
+        assertPresentStep.target = findActionToSeleniumTarget(step.primaryAction);
+        return [assertPresentStep];
+    }
+    else if (step.assertionType === 'not_present') {
+        if (step.primaryAction instanceof GetUrlAction_1.GetUrlAction) {
+            throw new Error('Invalid state. You cannot assert presence against URL properties.');
+        }
+        if (step.primaryAction instanceof GetVariableValue_1.GetVariableValue) {
+            throw new Error('Invalid state. You cannot assert presence against variable properties.');
+        }
+        const assertNotPresentStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('assertElementNotPresent', step);
+        assertNotPresentStep.target = findActionToSeleniumTarget(step.primaryAction);
+        return [assertNotPresentStep];
+    }
+    return buildSeleniumIdeJsAssertion(stepIndex, (!(0, GetCurrentLocationDescriptor_1.isGetCurrentLocationDescriptor)(find) &&
+        !(0, GetVariableDescriptor_1.isGetVariableDescriptor)(find) &&
+        find.findType === domUtil_1.FindType.FIND_ONE &&
+        find.findTarget.selector.xpath) ||
+        '', step.extractAction ? step.extractAction.extractionAttribute : '', (0, SeleniumIdeStep_1.substituteSeleniumVariable)(step.conditionAction.conditionValueAttribute || ''), step.assertionType, step, (_a = step.conditionAction.options) === null || _a === void 0 ? void 0 : _a.caseInsensitive);
+}
+function unsupportedSelIdeExportStep(step) {
+    const seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('echo', step);
+    const findDescriptor = step.primaryAction.toDescriptor();
+    seleniumStep.value = `[${step.getStepName()}] step with find type [${FindAction_1.findTypesToFormattedType[(!(0, GetCurrentLocationDescriptor_1.isGetCurrentLocationDescriptor)(findDescriptor) &&
+        !(0, GetVariableDescriptor_1.isGetVariableDescriptor)(findDescriptor) &&
+        findDescriptor.findType) ||
+        'unknown']} is not supported for Selenium IDE export`;
+    return seleniumStep;
+}
+function buildSeleniumIdeJsAssertion(stepIndex, xpath, assertionAttribute, assertAgainst, assertionType, step, caseInsensitive = false) {
+    const variableName = `assertVariable-${stepIndex}`;
+    let storeAttribute;
+    if (assertionAttribute !== 'innerText') {
+        storeAttribute = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('executeScript', step);
+        storeAttribute.target = `return document.evaluate('${xpath}', document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue['${assertionAttribute}']`;
+    }
+    else {
+        storeAttribute = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('storeText', step);
+        storeAttribute.target = `xpath=${xpath}`;
+    }
+    storeAttribute.value = variableName;
+    let condition = '';
+    const toLowerCaseString = caseInsensitive
+        ? '.toUpperCase().toLowerCase()'
+        : '';
+    switch (assertionType) {
+        case 'equals':
+            condition = `\${${variableName}}${toLowerCaseString} !== '${assertAgainst}'${toLowerCaseString}`;
+            break;
+        case 'does_not_equal':
+            condition = `\${${variableName}}${toLowerCaseString} === '${assertAgainst}'${toLowerCaseString}`;
+            break;
+        case 'contains':
+            condition = `!\${${variableName}}${toLowerCaseString}.includes('${assertAgainst}'${toLowerCaseString})`;
+            break;
+        case 'does_not_contain':
+            condition = `\${${variableName}}${toLowerCaseString}.includes('${assertAgainst}'${toLowerCaseString})`;
+            break;
+        case 'starts_with':
+            condition = `!\${${variableName}}${toLowerCaseString}.startsWith('${assertAgainst}'${toLowerCaseString})`;
+            break;
+        case 'starts_without':
+            condition = `\${${variableName}}${toLowerCaseString}.startsWith('${assertAgainst}'${toLowerCaseString})`;
+            break;
+        case 'ends_with':
+            condition = `!\${${variableName}}${toLowerCaseString}.endsWith('${assertAgainst}'${toLowerCaseString})`;
+            break;
+        case 'ends_without':
+            condition = `\${${variableName}}${toLowerCaseString}.endsWith('${assertAgainst}'${toLowerCaseString})`;
+            break;
+        case 'greater_than':
+            condition = `!\${${variableName}}${toLowerCaseString} > '${assertAgainst}'${toLowerCaseString}`;
+            break;
+        case 'less_than':
+            condition = `!\${${variableName}}${toLowerCaseString} < '${assertAgainst}'${toLowerCaseString}`;
+            break;
+        case 'greater_than_or_equals':
+            condition = `!\${${variableName}}${toLowerCaseString} >= '${assertAgainst}'${toLowerCaseString}`;
+            break;
+        case 'less_than_or_equals':
+            condition = `!\${${variableName}}${toLowerCaseString} <= '${assertAgainst}'${toLowerCaseString}`;
+            break;
+    }
+    const ifStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('if', step);
+    ifStep.target = condition;
+    const throwError = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('executeScript', step);
+    throwError.target = `throw new Error('${AssertStep_1.fieldToAssertionStep[assertionType]} step failure')`;
+    const endStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('end', step);
+    return [storeAttribute, ifStep, throwError, endStep];
+}
+function hoverStepToSeleniumSteps(step, _stepIndex) {
+    const hoverStep = step;
+    if (!hoverStep) {
+        throw new Error('Expected HoverStep');
+    }
+    const seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('mouseOver', hoverStep);
+    seleniumStep.target = findActionToSeleniumTarget(hoverStep.findAction);
+    return [seleniumStep];
+}
+exports.hoverStepToSeleniumSteps = hoverStepToSeleniumSteps;
+function echoStepToSeleniumSteps(step, _stepIndex) {
+    const echoStep = step;
+    if (!echoStep) {
+        throw new Error(`Expected echo step`);
+    }
+    const seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('echo', echoStep);
+    seleniumStep.target = (0, SeleniumIdeStep_1.substituteSeleniumVariable)(echoStep.echoValue);
+    return [seleniumStep];
+}
+exports.echoStepToSeleniumSteps = echoStepToSeleniumSteps;
+function clickStepToSeleniumSteps(step, _stepIndex) {
+    const clickStep = step;
+    if (!clickStep) {
+        throw new Error('Expected a click step');
+    }
+    const seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('click', step);
+    seleniumStep.target = findActionToSeleniumTarget(clickStep.findAction);
+    return [seleniumStep];
+}
+exports.clickStepToSeleniumSteps = clickStepToSeleniumSteps;
+function createVariableStepToSeleniumSteps(step, _stepIndex) {
+    let seleniumStep;
+    const createVariableStep = step;
+    if (!createVariableStep) {
+        throw new Error('Step is not a CreateVariableStep');
+    }
+    switch (createVariableStep.generationType) {
+        case CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE:
+            if (createVariableStep.actions[1].extractionAttribute ===
+                'innerText') {
+                seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('storeText', createVariableStep);
+            }
+            else {
+                seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('storeAttribute', createVariableStep);
+            }
+            seleniumStep.target = findActionToSeleniumTarget(createVariableStep.actions[0]);
+            seleniumStep.value = createVariableStep.variableName;
+            return [seleniumStep];
+        case CreateVariableStepDescriptor_1.VariableGenerator.PATTERN:
+            const generateString = createVariableStep.actions[0].generateString;
+            const translated = generateString.replace(/{{([^{}]+)}}/g, (_match, p1) => {
+                let cleaned = p1;
+                if (cleaned[0] === '@') {
+                    cleaned = cleaned.replace('@user.', '');
+                    return '` + ${' + cleaned + '} + `';
+                }
+                const length = p1.split(':')[1];
+                return `\${Math.round((Math.pow(36, ${length} + 1) - Math.random() * Math.pow(36, ${length}))).toString(36).slice(1)}`;
+            });
+            const executeScript = 'return ' + '`' + translated + '`';
+            seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('executeScript', createVariableStep);
+            seleniumStep.target = executeScript;
+            seleniumStep.value = createVariableStep.variableName;
+            return [seleniumStep];
+        case CreateVariableStepDescriptor_1.VariableGenerator.EMAIL:
+            seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('echo', createVariableStep);
+            seleniumStep.value = `Generate email address for variable name '${createVariableStep.variableName} is not supported for Selenium IDE export`;
+            return [seleniumStep];
+        case CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT:
+            seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('echo', createVariableStep);
+            seleniumStep.value = `Find and store count of elements for variable name '${createVariableStep.variableName} is not supported for Selenium IDE export`;
+            return [seleniumStep];
+        case CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT:
+            seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('echo', createVariableStep);
+            seleniumStep.value = `[${createVariableStep.getStepName()}${createVariableStep.actions[0].javaScript
+                ? ' from JavaScript'
+                : ''}] step for variable name '${createVariableStep.variableName} is not supported for Selenium IDE export`;
+            return [seleniumStep];
+    }
+}
+exports.createVariableStepToSeleniumSteps = createVariableStepToSeleniumSteps;
+function doubleClickStepToSeleniumSteps(step, _stepIndex) {
+    const doubleClickStep = step;
+    if (!doubleClickStep) {
+        throw new Error('Expected DoubleClickStep');
+    }
+    const seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('doubleClick', step);
+    seleniumStep.target = findActionToSeleniumTarget(doubleClickStep.findAction);
+    return [seleniumStep];
+}
+function enterTextStepToSeleniumSteps(step, _stepIndex) {
+    const enterTextStep = step;
+    if (!enterTextStep) {
+        throw new Error(`Expected EnterTextStep`);
+    }
+    const seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('type', enterTextStep);
+    seleniumStep.target = findActionToSeleniumTarget(enterTextStep.findAction);
+    seleniumStep.value = (0, SeleniumIdeStep_1.substituteSeleniumVariable)(enterTextStep.text);
+    return [seleniumStep];
+}
+exports.enterTextStepToSeleniumSteps = enterTextStepToSeleniumSteps;
+function navigateStepToSeleniumSteps(step, _stepIndex) {
+    const navigateStep = step;
+    if (!navigateStep) {
+        throw new Error('Expected NavigateStep');
+    }
+    const seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('executeScript', navigateStep);
+    seleniumStep.target = 'window.location.reload()';
+    return [seleniumStep];
+}
+function rightClickStepToSeleniumSteps(step, _stepIndex) {
+    const rightClickStep = step;
+    if (!rightClickStep) {
+        throw new Error('Expected RightClickStep');
+    }
+    const seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('contextClick', rightClickStep);
+    seleniumStep.target = findActionToSeleniumTarget(rightClickStep.findAction);
+    return [seleniumStep];
+}
+const SEL_IDE_KEYS = {
+    Alt: 'KEY_ALT',
+    ArrowDown: 'KEY_DOWN',
+    ArrowLeft: 'KEY_LEFT',
+    ArrowRight: 'KEY_RIGHT',
+    ArrowUp: 'KEY_UP',
+    Backspace: 'KEY_BACKSPACE',
+    Control: 'KEY_CTRL',
+    Delete: 'KEY_DELETE',
+    End: 'KEY_END',
+    Enter: 'KEY_ENTER',
+    Equals: 'KEY_EQUALS',
+    Escape: 'KEY_ESCAPE',
+    Home: 'KEY_HOME',
+    Insert: 'KEY_INSERT',
+    Meta: 'KEY_META',
+    PageDown: 'KEY_PAGE_DOWN',
+    PageUp: 'KEY_PAGE_UP',
+    Shift: 'KEY_SHIFT',
+    Space: 'KEY_SPACE',
+    Tab: 'KEY_TAB',
+};
+function sendKeyStepToSeleniumSteps(step, _stepIndex) {
+    const sendKeyStep = step;
+    if (!sendKeyStep) {
+        throw new Error('Expected SendKeyStep');
+    }
+    const seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('sendKeys', sendKeyStep);
+    seleniumStep.target = findActionToSeleniumTarget(sendKeyStep.findAction);
+    seleniumStep.value = sendKeyStep.keys
+        .map((keyPress) => {
+        if (Object.keys(SEL_IDE_KEYS).includes(keyPress.key)) {
+            return `\${${SEL_IDE_KEYS[keyPress.key]}}`;
+        }
+        return keyPress.key;
+    })
+        .join('');
+    return [seleniumStep];
+}
+function setViewportStepToSeleniumSteps(step, _stepIndex) {
+    const viewportStep = step;
+    if (!viewportStep) {
+        throw new Error('Expected SetViewportStep');
+    }
+    const seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('setWindowSize', viewportStep);
+    const width = viewportStep.size.width || 1920;
+    const height = viewportStep.size.height || 1080;
+    seleniumStep.target = (0, SeleniumIdeStep_1.substituteSeleniumVariable)(`${width}x${height}`);
+    return [seleniumStep];
+}
+function switchContextStepToSeleniumSteps(step, _stepIndex) {
+    const switchContextStep = step;
+    if (!switchContextStep) {
+        throw new Error('Expected SwitchContextStep');
+    }
+    if ((0, SwitchContextStepDescriptor_1.isSwitchRoot)(switchContextStep.switch) &&
+        switchContextStep.switch.frame === 'root') {
+        const seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('selectWindow', switchContextStep);
+        seleniumStep.target = 'window=0';
+        return [seleniumStep];
+    }
+    else if ((0, SwitchContextStepDescriptor_1.isSwitchTab)(switchContextStep.switch)) {
+        const seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('selectWindow', switchContextStep);
+        seleniumStep.target =
+            switchContextStep.switch.tab.findTarget === 'initial'
+                ? 'tab=0'
+                : `title="${switchContextStep.switch.tab.findTarget.title}"`;
+        return [seleniumStep];
+    }
+    const seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('selectFrame', switchContextStep);
+    if (switchContextStep.findAction) {
+        seleniumStep.target = findActionToSeleniumTarget(switchContextStep.findAction);
+    }
+    return [seleniumStep];
+}
+function findActionToSeleniumTarget(action) {
+    switch (action.findDescriptor.findType) {
+        case domUtil_1.FindType.FIND_FIRST:
+        case domUtil_1.FindType.FIND_LAST:
+        case domUtil_1.FindType.FIND_ANY:
+        case domUtil_1.FindType.FIND_ALL:
+            if ((0, domUtil_1.isCssSelector)(action.findDescriptor.findTarget)) {
+                return `css=${action.findDescriptor.findTarget.css_query}`;
+            }
+            return `xpath=${action.findDescriptor.findTarget.xpath}`;
+        case domUtil_1.FindType.FIND_ONE:
+            return `xpath=${action.findDescriptor.findTarget.selector.xpath}`;
+        default:
+            throw new Error(`Error generating SeleniumIDE target for ${action.getActionName()}: Unimplemented find type ${action.findDescriptor.findType}`);
+    }
+}
+function visitUrlStepToSeleniumSteps(step, _stepIndex) {
+    const visitUrlStep = step;
+    if (!visitUrlStep) {
+        throw new Error('Expected VisitUrlStep');
+    }
+    const seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('open', visitUrlStep);
+    seleniumStep.target = (0, SeleniumIdeStep_1.substituteSeleniumVariable)(visitUrlStep.url);
+    return [seleniumStep];
+}
+function waitStepToSeleniumSteps(step, _stepIndex) {
+    const waitStep = step;
+    if (!waitStep) {
+        throw new Error('Expected WaitStep');
+    }
+    const seleniumStep = (0, SeleniumIdeStep_1.buildSeleniumIdeStep)('pause', waitStep);
+    seleniumStep.target = `${waitStep.milliseconds}`;
+    return [seleniumStep];
+}

package/commands/flows/flows_cmds/export.js

@@ -4,7 +4,7 @@ const mablApiClientFactory_1 = require("../../../api/mablApiClientFactory");
 const util_1 = require("../../commandUtil/util");
 const js_yaml_1 = require("js-yaml");
 const constants_1 = require("../../constants");
-const flowConfigGenerator_1 = require("../../../configGenerators/flowConfigGenerator");
+const flowConfigGenerator_1 = require("../../../codeGenerators/seleniumConfigGenerators/flowConfigGenerator");
 const fileUtil_1 = require("../../commandUtil/fileUtil");
 const os = require('os');
 const JSON_REPLACER = null;

package/commands/tests/tests_cmds/export.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const mablApi_1 = require("../../../mablApi");
 const mablApiClientFactory_1 = require("../../../api/mablApiClientFactory");
-const selIdeGenerator_1 = require("../../../configGenerators/selIdeGenerator");
+const selIdeGenerator_1 = require("../../../codeGenerators/seleniumConfigGenerators/selIdeGenerator");
 const util_1 = require("../../commandUtil/util");
-const testConfigGenerator_1 = require("../../../configGenerators/testConfigGenerator");
+const testConfigGenerator_1 = require("../../../codeGenerators/seleniumConfigGenerators/testConfigGenerator");
 const js_yaml_1 = require("js-yaml");
 const constants_1 = require("../../constants");
 const loggingProvider_1 = require("../../../providers/logging/loggingProvider");