@mablhq/playwright-tools 2.49.1

package/mablscript/MablAction.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertObjectToMablscriptArgs = exports.distinctStrings = exports.parseArgument = exports.argumentIsMablVariable = exports.MablAction = void 0;
+const domUtil_1 = require("../domUtil");
+const MablSymbol_1 = require("./MablSymbol");
+class MablAction {
+    constructor(name, actionCode, args) {
+        this.name = name;
+        this.args = args;
+        this.actionCode = actionCode;
+    }
+    getActionArgs() {
+        return this.args ? this.args : [];
+    }
+    setActionSourceIndexInStep(index) {
+        this.actionSourceIndexInStep = index;
+    }
+    getActionSourceIndexInStep() {
+        return this.actionSourceIndexInStep;
+    }
+    getActionCode() {
+        return this.actionCode;
+    }
+    subVariable(argument) {
+        if (argumentIsMablVariable(argument)) {
+            const matches = argument.match(MablSymbol_1.SINGLE_VARIABLE_PATTERN_REGEX);
+            if (matches) {
+                return matches[1];
+            }
+        }
+        return `${argument}`;
+    }
+    getActionName() {
+        return this.name;
+    }
+    toMablscript() {
+        return '';
+    }
+    static findUniqueVariableReferencesInValue(value) {
+        const variableReferences = [];
+        if ((0, MablSymbol_1.isMablSymbolObject)(value)) {
+            return [value.name];
+        }
+        else if (typeof value === 'string') {
+            variableReferences.push(...(0, domUtil_1.findVariables)(value));
+        }
+        else if (Array.isArray(value)) {
+            variableReferences.push(...value.flatMap((v) => MablAction.findUniqueVariableReferencesInValue(v)));
+        }
+        else if (typeof value === 'object') {
+            variableReferences.push(...Object.values(value).flatMap((v) => MablAction.findUniqueVariableReferencesInValue(v)));
+        }
+        else {
+            return [];
+        }
+        return distinctStrings(variableReferences);
+    }
+    getInputVariables() {
+        return [];
+    }
+    getOutputVariables() {
+        return [];
+    }
+}
+exports.MablAction = MablAction;
+function argumentIsMablVariable(argument) {
+    return MablSymbol_1.SINGLE_VARIABLE_PATTERN_REGEX.test(argument);
+}
+exports.argumentIsMablVariable = argumentIsMablVariable;
+function parseArgument(arg) {
+    var _a;
+    if (typeof arg === 'string') {
+        const name = (_a = MablSymbol_1.SINGLE_VARIABLE_PATTERN_REGEX.exec(arg)) === null || _a === void 0 ? void 0 : _a[1];
+        if (name) {
+            return new MablSymbol_1.MablSymbol(name);
+        }
+    }
+    return arg;
+}
+exports.parseArgument = parseArgument;
+function distinctStrings(values) {
+    return Array.from(new Set(values));
+}
+exports.distinctStrings = distinctStrings;
+function convertObjectToMablscriptArgs(objectArgs) {
+    const mablArgs = Object.keys(objectArgs)
+        .sort()
+        .filter((key) => (objectArgs === null || objectArgs === void 0 ? void 0 : objectArgs[key]) !== undefined)
+        .map((key) => {
+        switch (typeof objectArgs[key]) {
+            case 'object':
+                return `${key}: ${convertObjectToMablscriptArgs(objectArgs[key])}`;
+            case 'boolean':
+            case 'number':
+                return `${key}: ${objectArgs[key]}`;
+            default:
+                return `${key}: "${(0, domUtil_1.escapeMablscriptString)(objectArgs[key])}"`;
+        }
+    });
+    return `{${mablArgs.join(', ')}}`;
+}
+exports.convertObjectToMablscriptArgs = convertObjectToMablscriptArgs;

package/mablscript/MablStep.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMablStepV1 = exports.buildObjectString = exports.buildSourceRepresentationOfObject = exports.MablStep = void 0;
+const domUtil_1 = require("../domUtil");
+const MablAction_1 = require("./MablAction");
+const MablSymbol_1 = require("./MablSymbol");
+const fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
+class MablStep extends MablAction_1.MablAction {
+    constructor(name, args, actions, actionCode) {
+        super(name, actionCode, args);
+        this.stepVersion = 1;
+        this.actions = actions;
+    }
+    getStepVersion() {
+        return this.stepVersion;
+    }
+    setStepId(id) {
+        this.id = id;
+    }
+    stepId() {
+        return this.id;
+    }
+    canContinueOnFailure() {
+        return false;
+    }
+    canFailAtEnd() {
+        return false;
+    }
+    getStepName() {
+        return 'UnimplementedStep';
+    }
+    isDisabled() {
+        return !!this.disabled;
+    }
+    setDisabled(disabled) {
+        this.disabled = disabled;
+    }
+    setAnnotation(annotation) {
+        this.annotation = annotation;
+    }
+    getAnnotation() {
+        return this.annotation;
+    }
+    setDescription(description) {
+        this.description = description;
+    }
+    getDescription() {
+        return this.description;
+    }
+    setStepSourceIndexInFlow(index) {
+        this.stepSourceIndexInFlow = index;
+    }
+    getStepSourceIndexInFlow() {
+        return this.stepSourceIndexInFlow;
+    }
+    getDescriptionForLogging() {
+        var _a;
+        return (((_a = this.annotation) === null || _a === void 0 ? void 0 : _a.description) || this.description || this.getStepName());
+    }
+    substituteMablscriptVariable(argument) {
+        if ((0, MablSymbol_1.isMablSymbolObject)(argument)) {
+            return argument.name;
+        }
+        if ((0, MablAction_1.argumentIsMablVariable)(argument)) {
+            const matches = argument.match(MablSymbol_1.SINGLE_VARIABLE_PATTERN_REGEX);
+            if (matches) {
+                return matches[1];
+            }
+        }
+        return `"${argument}"`;
+    }
+    toStepDescriptor(_fullLocatorsOn) {
+        const formatted = {
+            names: this.actions.map((action) => action.getActionName()),
+        };
+        formatted.names.push(this.getActionName());
+        return formatted;
+    }
+    annotationsOnStep() {
+        var _a, _b;
+        return !!((_a = this.annotation) === null || _a === void 0 ? void 0 : _a.note) || !!((_b = this.annotation) === null || _b === void 0 ? void 0 : _b.description);
+    }
+    annotationsAsYml() {
+        const result = {};
+        if (this.annotationsOnStep()) {
+            result.annotation = this.annotation;
+        }
+        if (this.description) {
+            result.description = this.description;
+        }
+        if (this.isDisabled()) {
+            result.disabled = this.isDisabled();
+        }
+        return result;
+    }
+    getFormattedStep(fullLocatorsOn) {
+        const formatted = {};
+        formatted[this.getStepName()] =
+            this.annotationsAsYml();
+        const { actionCode, ...stepDescriptor } = this.toStepDescriptor(fullLocatorsOn);
+        Object.assign(formatted[this.getStepName()], stepDescriptor);
+        if (this.stepId()) {
+            formatted[this.getStepName()].id = this.stepId();
+        }
+        return formatted;
+    }
+    toMablscript() {
+        return '';
+    }
+    toLineDiffFormat() {
+        const lineDiffProperties = {
+            annotation: this.annotation,
+            disabled: this.isDisabled(),
+            mablscript: this.toMablscript(),
+        };
+        return this.stringify(lineDiffProperties);
+    }
+    stringify(value) {
+        return (0, fast_json_stable_stringify_1.default)(value);
+    }
+    static cloneAndRemoveUndefinedEntriesFromObject(obj) {
+        const clone = {};
+        Object.entries(obj).forEach(([key, value]) => {
+            if (value !== undefined) {
+                if (typeof value !== 'object' || Array.isArray(value)) {
+                    clone[key] = value;
+                }
+                else {
+                    clone[key] = MablStep.cloneAndRemoveUndefinedEntriesFromObject(value);
+                }
+            }
+        });
+        return clone;
+    }
+}
+exports.MablStep = MablStep;
+MablStep.mablScriptStepNames = ['mablStep'];
+MablStep.yamlMablScriptNames = ['MablStep'];
+function buildSourceRepresentationOfObject(object) {
+    const stringedValues = Object.entries(object).map(([key, value]) => {
+        if (Array.isArray(value)) {
+            return `${key}: [${value
+                .map((arrayVal) => buildSourceRepresentationOfObject(arrayVal))
+                .join(', ')}]`;
+        }
+        else if (typeof value !== 'object') {
+            if (typeof value === 'number') {
+                return `${key}: ${value}`;
+            }
+            return `${key}: "${(0, domUtil_1.escapeMablscriptString)(value)}"`;
+        }
+        return `${key}: ${buildSourceRepresentationOfObject(value)}`;
+    });
+    return `{${stringedValues.join(', ')}}`;
+}
+exports.buildSourceRepresentationOfObject = buildSourceRepresentationOfObject;
+function buildObjectString(objectString) {
+    const final = [];
+    Object.keys(objectString)
+        .filter((key) => key !== 'value')
+        .forEach((key) => {
+        if (typeof objectString[key] === 'undefined') {
+            return final;
+        }
+        if (typeof objectString[key] === 'string') {
+            return final.push(`${key}: "${(0, domUtil_1.escapeMablscriptString)(objectString[key])}"`);
+        }
+        else if (typeof objectString[key] === 'number') {
+            return final.push(`${key}: ${objectString[key]}`);
+        }
+        else if (Array.isArray(objectString[key])) {
+            return final.push(`"${key}": [${objectString[key]
+                .map((arrayVal) => `"${(0, domUtil_1.escapeMablscriptString)(arrayVal)}"`)
+                .join(', ')}]`);
+        }
+        return final.push(`${key}: {${buildObjectString(objectString[key])}}`);
+    });
+    return final;
+}
+exports.buildObjectString = buildObjectString;
+function isMablStepV1(value) {
+    if (value === undefined || value === null) {
+        return false;
+    }
+    const mablStep = value;
+    return !!mablStep.getStepVersion && mablStep.getStepVersion() === 1;
+}
+exports.isMablStepV1 = isMablStepV1;

package/mablscript/MablStepV2.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMablStepV2WithMobileFindDescriptor = exports.isMablStepV2 = exports.MablStepV2 = void 0;
+const MablStep_1 = require("./MablStep");
+const StepWithMobileFindDescriptor_1 = require("./types/mobile/StepWithMobileFindDescriptor");
+class MablStepV2 extends MablStep_1.MablStep {
+    constructor(name, descriptor, actionCode) {
+        super(name, [], [], actionCode);
+        this.stepVersion = 2;
+        this.descriptor = descriptor;
+    }
+    stepId() {
+        return this.descriptor.id;
+    }
+    setStepId(id) {
+        this.descriptor.id = id;
+    }
+    static fromYaml(stepName, stepDescriptor, actionCode) {
+        return new MablStepV2(stepName, stepDescriptor, actionCode);
+    }
+    getStepName() {
+        return this.name;
+    }
+    toStepDescriptor() {
+        return this.descriptor;
+    }
+    getFormattedStep(_fullLocatorsOn) {
+        return {
+            [this.getStepName()]: {
+                description: this.stepDescription(),
+                ...this.descriptor,
+            },
+        };
+    }
+    stepDescription() {
+        throw new Error('Step description not implemented');
+    }
+    isDisabled() {
+        return !!this.descriptor.disabled;
+    }
+    setDisabled(disabled) {
+        this.descriptor.disabled = disabled;
+    }
+    getDescriptionForLogging() {
+        var _a;
+        return (((_a = this.annotation) === null || _a === void 0 ? void 0 : _a.description) ||
+            this.stepDescription() ||
+            this.getStepName());
+    }
+    toLineDiffFormat() {
+        const lineDiffProperties = {
+            annotation: this.annotation,
+            disabled: this.isDisabled(),
+            descriptor: this.toStepDescriptor(),
+        };
+        return this.stringify(lineDiffProperties);
+    }
+}
+exports.MablStepV2 = MablStepV2;
+MablStepV2.mablScriptStepNames = [];
+MablStepV2.yamlMablScriptNames = ['MablStepV2'];
+function isMablStepV2(value) {
+    if (value === undefined || value === null) {
+        return false;
+    }
+    const mablStep = value;
+    return !!mablStep.getStepVersion && mablStep.getStepVersion() === 2;
+}
+exports.isMablStepV2 = isMablStepV2;
+function isMablStepV2WithMobileFindDescriptor(value) {
+    return !!(isMablStepV2(value) && (0, StepWithMobileFindDescriptor_1.isStepWithMobileFindDescriptor)(value === null || value === void 0 ? void 0 : value.descriptor));
+}
+exports.isMablStepV2WithMobileFindDescriptor = isMablStepV2WithMobileFindDescriptor;

package/mablscript/MablSymbol.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMablSymbolObject = exports.formatSymbol = exports.MablSymbol = exports.SINGLE_VARIABLE_PATTERN_REGEX = exports.VARIABLE_PATTERN_REGEX = void 0;
+exports.VARIABLE_PATTERN_REGEX = /{{@([_.a-zA-Z0-9]+)}}/g;
+exports.SINGLE_VARIABLE_PATTERN_REGEX = /^{{@([_.a-zA-Z0-9]+)}}$/;
+class MablSymbol {
+    constructor(fullyQualifiedName) {
+        this.name = fullyQualifiedName;
+        this.tokens = fullyQualifiedName.split('.');
+    }
+    static fromString(formatted) {
+        const regEx = '{{@(?<name>.*)}}';
+        const found = formatted.match(regEx);
+        if (!(found === null || found === void 0 ? void 0 : found.groups)) {
+            throw new Error(`Invalid MablSymbol format: ${formatted}`);
+        }
+        const name = found.groups.name;
+        return new MablSymbol(name);
+    }
+    toString() {
+        return formatSymbol(this);
+    }
+}
+exports.MablSymbol = MablSymbol;
+function formatSymbol(symbol) {
+    if (isMablSymbolObject(symbol)) {
+        return '{{@' + symbol.name + '}}';
+    }
+    return '{{@' + symbol + '}}';
+}
+exports.formatSymbol = formatSymbol;
+function isMablSymbolObject(value) {
+    return !!((value === null || value === void 0 ? void 0 : value.name) && (value === null || value === void 0 ? void 0 : value.tokens));
+}
+exports.isMablSymbolObject = isMablSymbolObject;

package/mablscript/actions/AwaitDownloadAction.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwaitDownloadAction = void 0;
+const MablAction_1 = require("../MablAction");
+class AwaitDownloadAction extends MablAction_1.MablAction {
+    constructor(name, args) {
+        super(name, 'await_download', args);
+    }
+    toMablscript() {
+        return 'await_download()';
+    }
+}
+exports.AwaitDownloadAction = AwaitDownloadAction;
+AwaitDownloadAction.mablScriptStepNames = ['await_download'];

package/mablscript/actions/AwaitPDFDownloadAction.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwaitPDFDownloadAction = void 0;
+const AwaitDownloadAction_1 = require("./AwaitDownloadAction");
+const domUtil_1 = require("../../domUtil");
+class AwaitPDFDownloadAction extends AwaitDownloadAction_1.AwaitDownloadAction {
+    constructor(name, args) {
+        super(name, args);
+        this.pdfUUID = this.getActionArgs()[0].uuid;
+    }
+    toMablscript() {
+        return `await_pdf(${(0, domUtil_1.buildStepArgumentString)({
+            params: { uuid: this.pdfUUID },
+            legacy: true,
+        })})`;
+    }
+}
+exports.AwaitPDFDownloadAction = AwaitPDFDownloadAction;
+AwaitPDFDownloadAction.mablScriptStepNames = ['await_pdf'];

package/mablscript/actions/ConditionAction.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionAction = void 0;
+const domUtil_1 = require("../../domUtil");
+const MablAction_1 = require("../MablAction");
+const ConditionDescriptor_1 = require("../types/ConditionDescriptor");
+class ConditionAction extends MablAction_1.MablAction {
+    constructor(name, args) {
+        super(name, name, args);
+        this.hasOptionsAtInstantiation = false;
+        this.conditionDescriptor = this.getConditionDescriptor();
+    }
+    getConditionDescriptor() {
+        switch (this.name) {
+            case 'evaluate_condition':
+                return this.getEvaluateCondition();
+            case 'evaluate_presence':
+                return this.getEvaluatePresence();
+            case 'evaluate_ai_prompt':
+                return this.getEvaluateAIPrompt();
+            default:
+                throw new Error(`Unexpected condition name: ${this.name}`);
+        }
+    }
+    getEvaluateCondition() {
+        const conditionActionArgs = this.getActionArgs();
+        let conditionAttribute;
+        let conditionValueAttribute;
+        let options;
+        if (conditionActionArgs) {
+            [conditionAttribute, conditionValueAttribute, options] =
+                this.getActionArgs();
+        }
+        if (conditionValueAttribute === undefined) {
+            throw new Error('Invalid equality condition. Missing value to compare.');
+        }
+        if (conditionAttribute === undefined) {
+            throw new Error('Invalid equality condition. Missing comparison type.');
+        }
+        if (!(0, ConditionDescriptor_1.isComparisonType)(conditionAttribute)) {
+            throw new Error(`Invalid equality condition. Invalid comparison type: ${conditionAttribute}`);
+        }
+        if (options) {
+            this.hasOptionsAtInstantiation = true;
+        }
+        return {
+            conditionType: ConditionDescriptor_1.ConditionType.Comparison,
+            comparisonType: conditionAttribute,
+            comparatorValue: (0, MablAction_1.parseArgument)(conditionValueAttribute),
+            caseInsensitive: options === null || options === void 0 ? void 0 : options.caseInsensitive,
+        };
+    }
+    getEvaluatePresence() {
+        const conditionActionArgs = this.getActionArgs();
+        let conditionAttribute;
+        if (conditionActionArgs) {
+            [conditionAttribute] = this.getActionArgs();
+        }
+        if (!conditionAttribute) {
+            throw new Error('Invalid evaluate presence condition. Missing evaluation_type.');
+        }
+        return {
+            conditionType: ConditionDescriptor_1.ConditionType.Presence,
+            presenceType: ConditionDescriptor_1.PresenceEvaluationType.fromString(conditionAttribute),
+        };
+    }
+    getEvaluateAIPrompt() {
+        const conditionActionArgs = this.getActionArgs();
+        let userPrompt;
+        let options;
+        if (conditionActionArgs) {
+            [userPrompt, options] = this.getActionArgs();
+        }
+        if (userPrompt === undefined) {
+            throw new Error('Invalid ai prompt condition. Missing user prompt');
+        }
+        return {
+            conditionType: ConditionDescriptor_1.ConditionType.AIPrompt,
+            userPrompt,
+            metaPrompt: typeof options === 'string' ? options : options === null || options === void 0 ? void 0 : options.metaPrompt,
+            criteria: options === null || options === void 0 ? void 0 : options.criteria,
+        };
+    }
+    generateEvaluateConditionMablscript() {
+        var _a;
+        const comparatorValue = (0, ConditionDescriptor_1.getOptionalComparatorValue)(this.conditionDescriptor);
+        let value = '';
+        if (comparatorValue !== undefined) {
+            if (!(0, MablAction_1.argumentIsMablVariable)(comparatorValue)) {
+                value = `, "${(0, domUtil_1.escapeMablscriptString)(comparatorValue)}"`;
+            }
+            else {
+                value = `, ${this.subVariable(comparatorValue)}`;
+            }
+        }
+        const conditionOptionsString = this.hasOptionsAtInstantiation
+            ? `, ${(0, MablAction_1.convertObjectToMablscriptArgs)((_a = (0, ConditionDescriptor_1.getOptionalConditionOptions)(this.conditionDescriptor)) !== null && _a !== void 0 ? _a : {})}`
+            : '';
+        return `${this.name}("${(0, ConditionDescriptor_1.getAssertionConditionFieldFromDescriptor)(this.conditionDescriptor)}"${value}${conditionOptionsString})`;
+    }
+    toMablscript() {
+        return `${this.generateEvaluateConditionMablscript()}`;
+    }
+    getInputVariables() {
+        var _a;
+        const fields = [];
+        fields.push((_a = (0, ConditionDescriptor_1.getOptionalComparatorValue)(this.conditionDescriptor)) !== null && _a !== void 0 ? _a : '');
+        if ((0, ConditionDescriptor_1.isAIPromptCondition)(this.conditionDescriptor)) {
+            if (this.conditionDescriptor.criteria) {
+                fields.push(...this.conditionDescriptor.criteria);
+            }
+            fields.push(this.conditionDescriptor.userPrompt);
+        }
+        return MablAction_1.MablAction.findUniqueVariableReferencesInValue(fields);
+    }
+}
+exports.ConditionAction = ConditionAction;
+ConditionAction.mablScriptStepNames = [
+    'evaluate_condition',
+    'evaluate_presence',
+    'evaluate_ai_prompt',
+];
+ConditionAction.yamlMablScriptNames = ['ConditionAction'];

package/mablscript/actions/CountAction.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CountAction = void 0;
+const MablAction_1 = require("../MablAction");
+class CountAction extends MablAction_1.MablAction {
+    constructor(name, args) {
+        super(name, 'count', args);
+        this.countDescriptor = { count: true };
+    }
+    toMablscript() {
+        return `count()`;
+    }
+}
+exports.CountAction = CountAction;
+CountAction.mablScriptStepNames = ['count'];
+CountAction.yamlMablScriptNames = ['CountAction'];

package/mablscript/actions/ExtractAction.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractAction = exports.ExtractTypeName = exports.CSS_EXTRACTION_VALUE = exports.EXTRACTION_TYPE_KEY = void 0;
+const MablAction_1 = require("../MablAction");
+const ExtractDescriptor_1 = require("../types/ExtractDescriptor");
+exports.EXTRACTION_TYPE_KEY = 'extraction_type';
+exports.CSS_EXTRACTION_VALUE = 'css';
+var ExtractTypeName;
+(function (ExtractTypeName) {
+    ExtractTypeName["CssProperty"] = "CssProperty";
+    ExtractTypeName["ElementAttribute"] = "ElementAttribute";
+    ExtractTypeName["EmailAttribute"] = "EmailAttribute";
+})(ExtractTypeName || (exports.ExtractTypeName = ExtractTypeName = {}));
+class ExtractAction extends MablAction_1.MablAction {
+    constructor(name, args) {
+        super(name, name, args);
+        if (this.name === ExtractDescriptor_1.ExtractType.EXTRACT_INNER_TEXT) {
+            this.name = ExtractDescriptor_1.ExtractType.EXTRACT_ATTRIBUTE;
+            this.extractionAttribute = 'innerText';
+        }
+        else {
+            this.extractionAttribute = this.getActionArgs()[0];
+        }
+        if (this.name === ExtractDescriptor_1.ExtractType.EXTRACT_ATTRIBUTE && this.args.length > 1) {
+            const extractionOptions = this.args[1];
+            const metaExtractionType = extractionOptions.extraction_type;
+            if ((metaExtractionType === null || metaExtractionType === void 0 ? void 0 : metaExtractionType.toLowerCase()) === exports.CSS_EXTRACTION_VALUE) {
+                this.extractionType = ExtractDescriptor_1.ExtractType.EXTRACT_CSS_PROPERTIES.toString();
+            }
+            else {
+                this.extractionType = this.name;
+            }
+        }
+        else {
+            this.extractionType = this.name;
+        }
+        this.extractDescriptor = this.getExtractDescriptor();
+    }
+    getExtractDescriptor() {
+        if (!this.extractionAttribute) {
+            throw new Error(`Attribute name is required for extract attribute action.`);
+        }
+        if (typeof this.extractionAttribute !== 'string') {
+            throw new Error(`Invalid attribute provided for extract attribute extractor: ${this.extractionAttribute}`);
+        }
+        return {
+            extractType: ExtractDescriptor_1.ExtractType.fromString(this.extractionType),
+            attributeName: this.extractionAttribute,
+        };
+    }
+    toMablscript() {
+        if (this.extractionType === ExtractDescriptor_1.ExtractType.EXTRACT_CSS_PROPERTIES) {
+            return `extract_attribute("${this.extractionAttribute}", {${exports.EXTRACTION_TYPE_KEY}: "${exports.CSS_EXTRACTION_VALUE}"})`;
+        }
+        return `${this.extractionType}("${this.extractionAttribute}")`;
+    }
+    static mablScriptTypeFromYamlType(yamlType) {
+        return (Object.keys(ExtractAction.mablscriptToYamlType).find((key) => ExtractAction.mablscriptToYamlType[key] === yamlType) || 'extract_attribute');
+    }
+}
+exports.ExtractAction = ExtractAction;
+ExtractAction.mablScriptStepNames = [
+    'extract_attribute',
+    'extract_email_attribute',
+    'extract_inner_text',
+];
+ExtractAction.mablscriptToYamlType = {
+    extract_attribute: ExtractTypeName.ElementAttribute,
+    extract_css_property: ExtractTypeName.CssProperty,
+    extract_email_attribute: ExtractTypeName.EmailAttribute,
+};