@mablhq/mabl-cli 2.72.0 → 2.72.4

package/mablscript/steps/SendKeyStep.js

@@ -5,50 +5,69 @@ const FindAction_1 = require("../actions/FindAction");
 const domUtil_1 = require("../../domUtil");
 const SendKeyStepDescriptor_1 = require("../types/SendKeyStepDescriptor");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
+const STEP_NAME = 'SendKeys';
 class SendKeyStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(descriptor, findAction) {
-        super(SendKeyStep.stepName, descriptor, SendKeyStep.actionCode, findAction);
-        this.keys = descriptor.keys;
-    }
-    static validateActionsAndGetFindAction(name, actions) {
-        if (actions.length !== 1 || !(actions[0] instanceof FindAction_1.FindAction)) {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'send_keys');
+        if (this.actions.length !== 1 && !(this.actions[0] instanceof FindAction_1.FindAction)) {
             throw new Error(`${name} step should have one sub-action and it should be a find`);
         }
-        if ((0, domUtil_1.isFindElementType)(actions[0].getActionName())) {
-            return actions[0];
+        if ((0, domUtil_1.isFindElementType)(this.actions[0].getActionName())) {
+            this.findAction = this.actions[0];
         }
-        throw new Error(`Unexpected find action for ${name} step: ${JSON.stringify(actions[0])}`);
-    }
-    static validateKeys(name, args) {
-        if (!args?.length) {
+        else {
+            throw new Error(`Unexpected find action for ${name} step: ${JSON.stringify(this.actions[0])}`);
+        }
+        const keys = this.getActionArgs();
+        if (!keys?.length) {
             throw new Error(`${name} step expects at least one key`);
         }
-        if (args.every(SendKeyStepDescriptor_1.isCrossPlatformKeyPress)) {
-            return args;
+        if (keys.every(SendKeyStepDescriptor_1.isCrossPlatformKeyPress)) {
+            this.keys = keys;
+        }
+        else {
+            throw new Error(`Unexpected key format for ${name} step: ${JSON.stringify(keys)}`);
         }
-        throw new Error(`Unexpected key format for ${name} step: ${JSON.stringify(args)}`);
     }
     getStepName() {
-        return SendKeyStep.stepName;
+        return STEP_NAME;
     }
     toStepDescriptor() {
-        return buildStepDescriptor(this.findAction, this.keys);
+        const find = this.findAction.toDescriptor();
+        switch (find.findType) {
+            case domUtil_1.FindType.FIND_FIRST:
+            case domUtil_1.FindType.FIND_LAST:
+            case domUtil_1.FindType.FIND_ANY:
+            case domUtil_1.FindType.FIND_ONE:
+                return {
+                    find,
+                    keys: this.keys,
+                    descriptorToActionMap: new Map().set(find, this.findAction),
+                    actionCode: this.actionCode,
+                };
+            default:
+                throw new Error(`Error generating step descriptor for ${this.getStepName()}: Unexpected find type ${find.findType}`);
+        }
     }
-    static fromYaml(_stepName, stepArgs) {
-        const keys = stepArgs.keys || stepArgs.sendKeys;
-        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
-        const stepDescriptor = buildStepDescriptor(findAction, keys);
-        const step = new SendKeyStep(stepDescriptor, findAction);
-        if (stepArgs.id) {
-            step.setStepId(stepArgs.id);
+    getFormattedStep() {
+        const step = {
+            [STEP_NAME]: {
+                ...super.annotationsAsYml(),
+                sendKeys: this.keys,
+                ...this.findAction.toYaml(),
+            },
+        };
+        if (this.stepId()) {
+            step[STEP_NAME].id = this.stepId();
         }
         return step;
     }
-    static fromLegacyMablscript(args, actions) {
-        const findAction = SendKeyStep.validateActionsAndGetFindAction(SendKeyStep.stepName, actions);
-        const keys = SendKeyStep.validateKeys(SendKeyStep.stepName, args);
-        const stepDescriptor = buildStepDescriptor(findAction, keys);
-        return new SendKeyStep(stepDescriptor, findAction);
+    static fromYaml(_stepName, stepArgs) {
+        const step = new SendKeyStep('send_keys', stepArgs.sendKeys, [
+            FindAction_1.FindAction.findActionFromStepArgs(stepArgs),
+        ]);
+        step.setStepId(stepArgs.id);
+        return step;
     }
     toMablscript() {
         const keysToSend = this.keys
@@ -59,150 +78,7 @@ class SendKeyStep extends MablStepWithFindAction_1.MablStepWithFindAction {
     getInputVariables() {
         return this.findAction.getInputVariables();
     }
-    stepDescription() {
-        const keypresses = this.generateHumanizedKeys(this.isPasswordField());
-        const pluralizedKeypress = this.keys.length > 1 ? 'keypresses' : 'keypress';
-        const elementDescription = this.humanizeFind();
-        return `Send "${keypresses}" ${pluralizedKeypress} to ${elementDescription}`;
-    }
-    isPasswordField() {
-        return false;
-    }
-    generateHumanizedKeys(isPasswordField) {
-        return this.keys
-            .map((key) => this.humanizeKeyInfo(key, isPasswordField))
-            .join('');
-    }
-    humanizeKeyInfo(keyInfo, isPasswordField) {
-        if (!keyInfo) {
-            return '';
-        }
-        const activeModifiers = SendKeyStep.getActiveModifiers(keyInfo, false);
-        const activeModifierStrings = activeModifiers.map((modifierKey) => SendKeyStep.modifierKeyHumanizedMap[modifierKey]);
-        const hasActiveModifiersFlag = !this.isEmpty(activeModifierStrings);
-        const activeModifiersPrefix = hasActiveModifiersFlag
-            ? activeModifierStrings.join('+') + '+'
-            : '';
-        const hasMacOverride = keyInfo.mac?.key;
-        const hasWindowsOverride = keyInfo.windows?.key;
-        let humanizedString = `${activeModifiersPrefix}${this.generateHumanizedKey(keyInfo, isPasswordField)}`;
-        if (hasMacOverride || hasWindowsOverride) {
-            humanizedString = `Default: ${humanizedString}`;
-        }
-        if (hasMacOverride) {
-            humanizedString += `, Mac: ${this.humanizeKeyInfo(keyInfo.mac, isPasswordField)}`;
-        }
-        if (hasWindowsOverride) {
-            humanizedString += `, Windows: ${this.humanizeKeyInfo(keyInfo.windows, isPasswordField)}`;
-        }
-        return humanizedString;
-    }
-    generateHumanizedKey(keyInfo, isPasswordField) {
-        if (SendKeyStep.keyIsSpecial(keyInfo.key)) {
-            return `[${keyInfo.key.toUpperCase()}]`;
-        }
-        return isPasswordField ? '*' : keyInfo.key;
-    }
-    static keyIsSpecial(key) {
-        return SendKeyStep.specialKeys.includes(key);
-    }
-    static getActiveModifiers(keyInfo, includeOverrides) {
-        const modifiers = SendKeyStep.getModifiers(keyInfo, includeOverrides);
-        return Object.keys(SendKeyStep.pickBy(modifiers));
-    }
-    static getModifiers(keyInfo, includeOverrides) {
-        const objectKeys = Object.keys(SendKeyStep.modifierKeyIdentifierMap);
-        let modifiers = SendKeyStep.pick(keyInfo, objectKeys);
-        if (includeOverrides) {
-            modifiers = {
-                ...modifiers,
-                ...SendKeyStep.pick(keyInfo, objectKeys.map((key) => `windows.${key}`)),
-                ...SendKeyStep.pick(keyInfo, objectKeys.map((key) => `mac.${key}`)),
-            };
-        }
-        return modifiers;
-    }
-    isEmpty(obj) {
-        return obj === undefined || Object.keys(obj).length === 0;
-    }
-    static pick(object, paths) {
-        const result = {};
-        for (const path of paths) {
-            if (path in object) {
-                result[path] = object[path];
-            }
-        }
-        return result;
-    }
-    static pickBy(object) {
-        const result = {};
-        for (const key in object) {
-            if (object[key]) {
-                result[key] = object[key];
-            }
-        }
-        return result;
-    }
 }
 exports.SendKeyStep = SendKeyStep;
-SendKeyStep.stepName = 'SendKeys';
-SendKeyStep.actionCode = 'send_keys';
-SendKeyStep.mablScriptStepNames = [SendKeyStep.actionCode];
-SendKeyStep.yamlMablScriptNames = [SendKeyStep.stepName];
-SendKeyStep.modifierKeyHumanizedMap = {
-    altKey: 'Alt',
-    ctrlKey: 'Ctrl',
-    metaKey: 'Cmd',
-    shiftKey: 'Shift',
-};
-SendKeyStep.modifierKeyIdentifierMap = {
-    altKey: false,
-    ctrlKey: false,
-    metaKey: false,
-    shiftKey: false,
-};
-SendKeyStep.specialKeys = [
-    'Enter',
-    'Tab',
-    'Escape',
-    'Backspace',
-    'Delete',
-    'ArrowUp',
-    'ArrowDown',
-    'ArrowLeft',
-    'ArrowRight',
-    'Home',
-    'End',
-    'PageUp',
-    'PageDown',
-    'Insert',
-    'F1',
-    'F2',
-    'F3',
-    'F4',
-    'F5',
-    'F6',
-    'F7',
-    'F8',
-    'F9',
-    'F10',
-    'F11',
-    'F12',
-];
-function buildStepDescriptor(findAction, keys) {
-    const find = findAction.toDescriptor();
-    switch (find.findType) {
-        case domUtil_1.FindType.FIND_FIRST:
-        case domUtil_1.FindType.FIND_LAST:
-        case domUtil_1.FindType.FIND_ANY:
-        case domUtil_1.FindType.FIND_ONE:
-            return {
-                find,
-                keys,
-                descriptorToActionMap: new Map().set(find, findAction),
-                actionCode: 'send_keys',
-            };
-        default:
-            throw new Error(`Error generating step descriptor for SendKeys: Unexpected find type ${find.findType}`);
-    }
-}
+SendKeyStep.mablScriptStepNames = ['send_keys'];
+SendKeyStep.yamlMablScriptNames = ['SendKeys'];

package/mablscript/steps/SetCookieStep.js

@@ -1,19 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SetCookieStep = void 0;
-const MablStepV2_1 = require("../MablStepV2");
+const MablStep_1 = require("../MablStep");
 const MablAction_1 = require("../MablAction");
 const CookieUtils_1 = require("./CookieUtils");
 const domUtil_1 = require("../../domUtil");
-class SetCookieStep extends MablStepV2_1.MablStepV2 {
-    constructor(descriptor) {
-        super(SetCookieStep.stepName, descriptor, SetCookieStep.actionCode);
-        this.cookieName = descriptor.name;
-        this.cookieValue = descriptor.value;
-        this.cookieOptions = descriptor.options;
+class SetCookieStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'set_cookie');
+        const cookieSelector = this.getActionArgs()[0];
+        this.cookieName = CookieUtils_1.CookieUtils.normalizeName(cookieSelector.name);
+        this.cookieValue = CookieUtils_1.CookieUtils.normalizeValue(cookieSelector.value);
+        const cookieOptions = {
+            domain: cookieSelector.domain,
+            path: cookieSelector.path,
+            expires: cookieSelector.expiry,
+            httpOnly: cookieSelector.http_only,
+            secure: cookieSelector.secure,
+            sameSite: cookieSelector.same_site,
+            url: cookieSelector.url,
+        };
+        if (Object.values(cookieOptions).filter((optionValue) => optionValue !== undefined).length > 0) {
+            this.cookieOptions = cookieOptions;
+        }
     }
     getStepName() {
-        return SetCookieStep.stepName;
+        return 'SetCookie';
     }
     toStepDescriptor() {
         return {
@@ -24,50 +36,10 @@ class SetCookieStep extends MablStepV2_1.MablStepV2 {
         };
     }
     static fromYaml(_stepName, stepArgs) {
-        const cookieName = CookieUtils_1.CookieUtils.normalizeName(stepArgs.name);
-        const cookieValue = CookieUtils_1.CookieUtils.normalizeValue(stepArgs.value);
-        const cookieOptions = {
-            domain: stepArgs.domain,
-            path: stepArgs.path,
-            expires: stepArgs.expiry,
-            httpOnly: stepArgs.http_only,
-            secure: stepArgs.secure,
-            sameSite: stepArgs.same_site,
-            url: stepArgs.url,
-        };
-        const hasOptions = Object.values(cookieOptions).filter((optionValue) => optionValue !== undefined).length > 0;
-        const stepDescriptor = {
-            name: cookieName,
-            value: cookieValue,
-            options: hasOptions ? cookieOptions : undefined,
-            actionCode: SetCookieStep.actionCode,
-        };
-        const step = new SetCookieStep(stepDescriptor);
+        const step = new SetCookieStep('set_cookie', [stepArgs], []);
         step.setStepId(stepArgs.id);
         return step;
     }
-    static fromLegacyMablscript(args, _actions) {
-        const cookieSelector = args[0];
-        const cookieName = CookieUtils_1.CookieUtils.normalizeName(cookieSelector.name);
-        const cookieValue = CookieUtils_1.CookieUtils.normalizeValue(cookieSelector.value);
-        const cookieOptions = {
-            domain: cookieSelector.domain,
-            path: cookieSelector.path,
-            expires: cookieSelector.expiry,
-            httpOnly: cookieSelector.http_only,
-            secure: cookieSelector.secure,
-            sameSite: cookieSelector.same_site,
-            url: cookieSelector.url,
-        };
-        const hasOptions = Object.values(cookieOptions).filter((optionValue) => optionValue !== undefined).length > 0;
-        const stepDescriptor = {
-            name: cookieName,
-            value: cookieValue,
-            options: hasOptions ? cookieOptions : undefined,
-            actionCode: SetCookieStep.actionCode,
-        };
-        return new SetCookieStep(stepDescriptor);
-    }
     toMablscript() {
         const cookieSelector = {
             name: this.cookieName,
@@ -91,12 +63,7 @@ class SetCookieStep extends MablStepV2_1.MablStepV2 {
             ...MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.cookieValue),
         ]);
     }
-    stepDescription() {
-        return `Set cookie: "${this.cookieName}"`;
-    }
 }
 exports.SetCookieStep = SetCookieStep;
-SetCookieStep.stepName = 'SetCookie';
-SetCookieStep.actionCode = 'set_cookie';
-SetCookieStep.mablScriptStepNames = [SetCookieStep.actionCode];
-SetCookieStep.yamlMablScriptNames = [SetCookieStep.stepName];
+SetCookieStep.mablScriptStepNames = ['set_cookie'];
+SetCookieStep.yamlMablScriptNames = ['SetCookie'];

package/mablscript/steps/SetFilesStep.js

@@ -5,31 +5,57 @@ const FindAction_1 = require("../actions/FindAction");
 const MablAction_1 = require("../MablAction");
 const domUtil_1 = require("../../domUtil");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
-const ActionsUtils_1 = require("./ActionsUtils");
 class SetFilesStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(descriptor, findAction) {
-        super(SetFilesStep.stepName, descriptor, SetFilesStep.actionCode, findAction);
-        this.files = descriptor.files;
+    constructor(name, args, actions) {
+        super(name, args, actions, 'set_files');
+        this.files = this.getActionArgs();
+        this.validate();
+        this.findAction = this.actions[0];
+    }
+    validate() {
+        if (this.actions.length !== 1 && !(this.actions[0] instanceof FindAction_1.FindAction)) {
+            throw new Error('Set files steps should have exactly on sub action and it should be a find');
+        }
     }
     getStepName() {
-        return SetFilesStep.stepName;
+        return 'SetFiles';
     }
     toStepDescriptor() {
-        return buildStepDescriptor(this.findAction, this.files);
+        const formatted = {};
+        formatted.files = this.files;
+        const find = this.findAction.toDescriptor();
+        switch (find.findType) {
+            case domUtil_1.FindType.FIND_FIRST:
+            case domUtil_1.FindType.FIND_LAST:
+            case domUtil_1.FindType.FIND_ANY:
+            case domUtil_1.FindType.FIND_ONE:
+                formatted.find = find;
+                formatted.descriptorToActionMap = new Map().set(find, this.findAction);
+                return formatted;
+            default:
+                throw new Error(`Error generating step descriptor for ${this.getStepName()}: Unexpected find type ${find.findType}`);
+        }
+    }
+    getFormattedStep(_fullLocatorsOn) {
+        const step = {
+            SetFiles: {
+                ...super.annotationsAsYml(),
+                ...this.findAction.toYaml(),
+                files: this.files,
+            },
+        };
+        if (this.stepId()) {
+            step.SetFiles.id = this.stepId();
+        }
+        return step;
     }
     static fromYaml(_stepName, stepArgs) {
-        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
-        const stepDescriptor = buildStepDescriptor(findAction, stepArgs.files);
-        const step = new SetFilesStep(stepDescriptor, findAction);
+        const step = new SetFilesStep('set_files', stepArgs.files, [
+            FindAction_1.FindAction.findActionFromStepArgs(stepArgs),
+        ]);
         step.setStepId(stepArgs.id);
         return step;
     }
-    static fromLegacyMablscript(args, actions) {
-        const files = args;
-        const findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(actions);
-        const stepDescriptor = buildStepDescriptor(findAction, files);
-        return new SetFilesStep(stepDescriptor, findAction);
-    }
     toMablscript() {
         const files = this.files
             .map((key) => (0, MablAction_1.convertObjectToMablscriptArgs)(key))
@@ -39,32 +65,7 @@ class SetFilesStep extends MablStepWithFindAction_1.MablStepWithFindAction {
     getInputVariables() {
         return this.findAction.getInputVariables();
     }
-    stepDescription() {
-        const fileCount = this.files.length;
-        const fileText = fileCount === 1 ? 'file' : 'files';
-        const elementDescription = this.humanizeFind();
-        return `Set ${fileCount} ${fileText} on ${elementDescription}`;
-    }
 }
 exports.SetFilesStep = SetFilesStep;
-SetFilesStep.stepName = 'SetFiles';
-SetFilesStep.actionCode = 'set_files';
-SetFilesStep.mablScriptStepNames = [SetFilesStep.actionCode];
-SetFilesStep.yamlMablScriptNames = [SetFilesStep.stepName];
-function buildStepDescriptor(findAction, files) {
-    const find = findAction.toDescriptor();
-    switch (find.findType) {
-        case domUtil_1.FindType.FIND_FIRST:
-        case domUtil_1.FindType.FIND_LAST:
-        case domUtil_1.FindType.FIND_ANY:
-        case domUtil_1.FindType.FIND_ONE:
-            return {
-                files,
-                find,
-                descriptorToActionMap: new Map().set(find, findAction),
-                actionCode: SetFilesStep.actionCode,
-            };
-        default:
-            throw new Error(`Error generating step descriptor for ${SetFilesStep.stepName}: Unexpected find type ${find.findType}`);
-    }
-}
+SetFilesStep.mablScriptStepNames = ['set_files'];
+SetFilesStep.yamlMablScriptNames = ['SetFiles'];

package/mablscript/steps/SetViewportStep.js

@@ -1,29 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SetViewportStep = void 0;
-const MablStepV2_1 = require("../MablStepV2");
-class SetViewportStep extends MablStepV2_1.MablStepV2 {
-    constructor(descriptor) {
-        super(SetViewportStep.stepName, descriptor, SetViewportStep.actionCode);
-        this.size = descriptor.size;
+const MablStep_1 = require("../MablStep");
+class SetViewportStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'set_viewport');
+        const viewportArg = this.getActionArgs()[0];
+        this.size = viewportArg?.size;
     }
     getStepName() {
-        return SetViewportStep.stepName;
+        return 'SetViewport';
     }
     toStepDescriptor() {
         return { size: this.size, actionCode: this.actionCode };
     }
-    static fromYaml(_stepName, stepDescriptor) {
-        return new SetViewportStep(stepDescriptor);
-    }
-    static fromLegacyMablscript(args, _actions) {
-        const stepDescriptor = {
-            size: {
-                width: args[0]?.size?.width ?? undefined,
-                height: args[0]?.size?.height ?? undefined,
-            },
-        };
-        return new SetViewportStep(stepDescriptor);
+    static fromYaml(_stepName, stepArgs) {
+        const step = new SetViewportStep('set_viewport', [stepArgs], []);
+        step.setStepId(stepArgs.id);
+        return step;
     }
     toMablscript() {
         let sizeArg;
@@ -38,27 +32,7 @@ class SetViewportStep extends MablStepV2_1.MablStepV2 {
         }
         return `set_viewport(${sizeArg})`;
     }
-    stepDescription() {
-        if (this.size) {
-            let message = 'Set viewport size';
-            const width = this.size.width;
-            const height = this.size.height;
-            if (width) {
-                message += ` to width ${width}`;
-                if (height) {
-                    message += ` and height ${height}`;
-                }
-            }
-            else if (height) {
-                message += ` to height ${height}`;
-            }
-            return message;
-        }
-        return `Invalid set viewport step definition`;
-    }
 }
 exports.SetViewportStep = SetViewportStep;
-SetViewportStep.stepName = 'SetViewport';
-SetViewportStep.actionCode = 'set_viewport';
-SetViewportStep.mablScriptStepNames = [SetViewportStep.actionCode];
-SetViewportStep.yamlMablScriptNames = [SetViewportStep.stepName];
+SetViewportStep.mablScriptStepNames = ['set_viewport'];
+SetViewportStep.yamlMablScriptNames = ['SetViewport'];