@mablhq/playwright-tools 2.49.1

package/mablscript/actions/FindAction.js

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeEmail = exports.isEmailSelectorOrDescriptor = exports.normalize = exports.isElementSelector = exports.FindAction = exports.formattedFindTypeToMablscript = exports.findTypesToFormattedType = void 0;
+const domUtil_1 = require("../../domUtil");
+const mablscriptFind_1 = require("../../mablscriptFind");
+const MablAction_1 = require("../MablAction");
+exports.findTypesToFormattedType = {
+    find_all: 'FindAll',
+    find_any: 'FindFirst',
+    find_cookie: 'FindCookie',
+    find_first: 'FindFirst',
+    find_one: 'FindOne',
+    find_email: 'FindEmail',
+    find_tab: 'FindTab',
+    find_last: 'FindLast',
+};
+exports.formattedFindTypeToMablscript = {};
+Object.entries(exports.findTypesToFormattedType).forEach(([findType, field]) => (exports.formattedFindTypeToMablscript[field] = findType));
+class FindAction extends MablAction_1.MablAction {
+    constructor(name, args) {
+        super(name, name, args);
+        const actionName = this.getActionName();
+        if (!(0, domUtil_1.isFindType)(actionName)) {
+            throw new Error(`Unknown find type for action: ${actionName}`);
+        }
+        const findType = domUtil_1.FindType.fromString(actionName);
+        this.isValid = true;
+        switch (findType) {
+            case domUtil_1.FindType.FIND_ONE: {
+                const [selectors, options] = this.getActionArgs();
+                if (!isElementSelector(selectors)) {
+                    this.isValid = false;
+                }
+                const [target, ancestor] = Array.isArray(selectors)
+                    ? [...selectors]
+                    : [selectors];
+                const findTarget = normalize(target);
+                if (ancestor) {
+                    findTarget.auxiliaryDescriptors = [normalize(ancestor)];
+                }
+                this.findDescriptor = {
+                    findType,
+                    findTarget,
+                };
+                if ((0, domUtil_1.isFindOptions)(options)) {
+                    this.findDescriptor.findOptions = options;
+                }
+                break;
+            }
+            case domUtil_1.FindType.FIND_FIRST:
+            case domUtil_1.FindType.FIND_LAST:
+            case domUtil_1.FindType.FIND_ANY:
+            case domUtil_1.FindType.FIND_ALL: {
+                const [primarySelector, foundElementSelectors, findOptions] = this.getActionArgs();
+                if (!(0, domUtil_1.isCssSelector)(primarySelector) &&
+                    !(0, domUtil_1.isXPathSelector)(primarySelector)) {
+                    this.isValid = false;
+                }
+                this.findDescriptor = {
+                    findOptions,
+                    findTarget: primarySelector,
+                    findType,
+                    foundElementSelectors,
+                    primarySelectors: primarySelector,
+                };
+                break;
+            }
+            case domUtil_1.FindType.FIND_COOKIE: {
+                const [selectors] = this.getActionArgs();
+                if (!(0, domUtil_1.isCookieSelector)(selectors)) {
+                    this.isValid = false;
+                }
+                this.findDescriptor = {
+                    findType,
+                    findTarget: selectors,
+                };
+                break;
+            }
+            case domUtil_1.FindType.FIND_EMAIL:
+                const [selectors] = this.getActionArgs();
+                if (!isEmailSelectorOrDescriptor(selectors)) {
+                    this.isValid = false;
+                }
+                const [target] = Array.isArray(selectors)
+                    ? [...selectors]
+                    : [selectors];
+                const findTarget = normalizeEmail(target);
+                this.findDescriptor = {
+                    findType,
+                    findTarget,
+                };
+                break;
+            case domUtil_1.FindType.FIND_TAB: {
+                const [selectors] = this.getActionArgs();
+                if (selectors !== 'initial' && !(0, domUtil_1.isTabSelector)(selectors)) {
+                    this.isValid = false;
+                }
+                this.findDescriptor = {
+                    findType,
+                    findTarget: selectors,
+                };
+            }
+        }
+        Object.freeze(this.findDescriptor);
+    }
+    toDescriptor() {
+        return this.findDescriptor;
+    }
+    static findActionFromStepArgs(stepArgs, suppliedFindType) {
+        let findType;
+        if (stepArgs.selector) {
+            if (suppliedFindType) {
+                findType = suppliedFindType;
+            }
+            else {
+                findType = stepArgs.findType
+                    ? exports.formattedFindTypeToMablscript[stepArgs.findType]
+                    : exports.formattedFindTypeToMablscript.FindOne;
+            }
+            if (!stepArgs.selectorAncestors) {
+                return new FindAction(findType, [
+                    stepArgs.selector,
+                    stepArgs.findOptions,
+                ]);
+            }
+            const ancestors = stepArgs.selectorAncestors || [];
+            return new FindAction(findType, [
+                [stepArgs.selector, ...ancestors],
+                stepArgs.findOptions,
+            ]);
+        }
+        throw new Error('No selector found in yaml');
+    }
+    toYaml() {
+        var _a;
+        const result = {};
+        const find = this.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_ALL:
+                result.find_type = find.findType;
+                result.selector = find.findTarget;
+                break;
+            case domUtil_1.FindType.FIND_ONE:
+                result.selector = find.findTarget.selector;
+                if ((_a = find.findTarget.auxiliaryDescriptors) === null || _a === void 0 ? void 0 : _a.length) {
+                    result.selectorAncestors = find.findTarget.auxiliaryDescriptors.map((descriptor) => descriptor.selector);
+                }
+                break;
+            default:
+                throw new Error(`Unexpected find type ${find.findType}`);
+        }
+        return result;
+    }
+    toMablscript() {
+        return this.generateFindMablscript();
+    }
+    generateFindMablscript() {
+        var _a;
+        let action = this.findDescriptor.findType;
+        let args = '';
+        switch (this.findDescriptor.findType) {
+            case domUtil_1.FindType.FIND_ONE:
+                const find = this.findDescriptor;
+                const selectors = ((_a = find.findTarget.auxiliaryDescriptors) === null || _a === void 0 ? void 0 : _a.length)
+                    ? '[' +
+                        [find.findTarget, ...find.findTarget.auxiliaryDescriptors]
+                            .map(mablscriptFind_1.buildFindDescriptorString)
+                            .filter(Boolean)
+                            .join(', ') +
+                        ']'
+                    : (0, mablscriptFind_1.buildFindDescriptorString)(find.findTarget);
+                const options = buildFindOptionsString(find.findOptions);
+                args = [selectors, options].filter(Boolean).join(', ');
+                break;
+            case domUtil_1.FindType.FIND_LAST:
+            case domUtil_1.FindType.FIND_ANY:
+            case domUtil_1.FindType.FIND_ALL:
+            case domUtil_1.FindType.FIND_FIRST: {
+                const find = this.findDescriptor;
+                const selector = (0, mablscriptFind_1.buildElementSelectorString)(find.findTarget);
+                let foundElementSelectors;
+                if (find.foundElementSelectors) {
+                    if (Array.isArray(find.foundElementSelectors)) {
+                        foundElementSelectors = find.foundElementSelectors
+                            .map((selector) => (0, mablscriptFind_1.buildFindDescriptorString)({ selector }))
+                            .join(', ');
+                    }
+                    else {
+                        foundElementSelectors = (0, mablscriptFind_1.buildFindDescriptorString)({
+                            selector: find.foundElementSelectors,
+                        });
+                    }
+                }
+                else {
+                    foundElementSelectors = '{selector_type: "element"}';
+                }
+                const options = buildFindOptionsString(find.findOptions);
+                args = [selector, foundElementSelectors, options]
+                    .filter(Boolean)
+                    .join(', ');
+                if (find.findType === domUtil_1.FindType.FIND_ANY) {
+                    action = domUtil_1.FindType.FIND_FIRST;
+                }
+                break;
+            }
+            case domUtil_1.FindType.FIND_COOKIE:
+                args = (0, mablscriptFind_1.buildCookieSelectorString)(this.findDescriptor.findTarget);
+                break;
+            case domUtil_1.FindType.FIND_EMAIL: {
+                args = (0, domUtil_1.buildFindEmailDescriptorString)(this.findDescriptor.findTarget);
+                break;
+            }
+            case domUtil_1.FindType.FIND_TAB:
+                args = (0, mablscriptFind_1.buildTabSelectorString)(this.findDescriptor.findTarget);
+                break;
+            default:
+                throw new Error(`Error generating mablscript: Unexpected find type in ${JSON.stringify(this.findDescriptor)}`);
+        }
+        return `${action}(${args})`;
+    }
+    isValidDescriptor() {
+        return this.isValid;
+    }
+    getInputVariables() {
+        return MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.findDescriptor);
+    }
+}
+exports.FindAction = FindAction;
+FindAction.mablScriptStepNames = [
+    'find_all',
+    'find_one',
+    'find_first',
+    'find_last',
+    'find_any',
+    'find_cookie',
+    'find_email',
+    'find_tab',
+];
+FindAction.yamlMablScriptNames = [
+    'FindAll',
+    'FindOne',
+    'FindFirst',
+    'FindLast',
+    'FindAny',
+    'FindCookie',
+    'FindEmail',
+    'FindTab',
+];
+function buildFindOptionsString(findOptions) {
+    if (!findOptions) {
+        return undefined;
+    }
+    return JSON.stringify(findOptions);
+}
+function isElementSelector(maybeSelectors) {
+    const [target, ancestor] = Array.isArray(maybeSelectors)
+        ? [...maybeSelectors]
+        : [maybeSelectors];
+    const validTarget = (0, domUtil_1.isStandardSelector)(target) || (0, domUtil_1.isNormalizedFindDescriptor)(target);
+    const validAncestor = !ancestor ||
+        (0, domUtil_1.isStandardSelector)(ancestor) ||
+        (0, domUtil_1.isNormalizedFindDescriptor)(ancestor);
+    return !!(validTarget && validAncestor);
+}
+exports.isElementSelector = isElementSelector;
+function normalize(maybeFindDescriptor) {
+    if ((0, domUtil_1.isNormalizedFindDescriptor)(maybeFindDescriptor)) {
+        return { ...maybeFindDescriptor };
+    }
+    return { selector: maybeFindDescriptor };
+}
+exports.normalize = normalize;
+function isEmailSelectorOrDescriptor(selectorOrDescriptor) {
+    const [target] = Array.isArray(selectorOrDescriptor)
+        ? [...selectorOrDescriptor]
+        : [selectorOrDescriptor];
+    return (0, domUtil_1.isEmailSelector)(target) || (0, domUtil_1.isNormalizedFindEmailDescriptor)(target);
+}
+exports.isEmailSelectorOrDescriptor = isEmailSelectorOrDescriptor;
+function normalizeEmail(selectorOrDescriptor) {
+    if ((0, domUtil_1.isNormalizedFindEmailDescriptor)(selectorOrDescriptor)) {
+        return { ...selectorOrDescriptor };
+    }
+    if ((0, domUtil_1.isEmailSelector)(selectorOrDescriptor)) {
+        if (selectorOrDescriptor.subject_exact) {
+            const { subject_exact: subjectExact, ...restOfObject } = selectorOrDescriptor;
+            return {
+                selector: {
+                    subject: subjectExact,
+                    ...restOfObject,
+                },
+                type: 'email',
+            };
+        }
+    }
+    return { selector: selectorOrDescriptor, type: 'email' };
+}
+exports.normalizeEmail = normalizeEmail;

package/mablscript/actions/GenerateEmailAddressAction.js

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

package/mablscript/actions/GenerateRandomStringAction.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateRandomStringAction = void 0;
+const MablAction_1 = require("../MablAction");
+const domUtil_1 = require("../../domUtil");
+class GenerateRandomStringAction extends MablAction_1.MablAction {
+    constructor(name, args) {
+        super(name, 'generate_random_string', args);
+        this.generateString = this.getActionArgs()[0];
+    }
+    toMablscript() {
+        return `generate_random_string(\"${(0, domUtil_1.escapeMablscriptString)(this.generateString)}\")`;
+    }
+    getInputVariables() {
+        return MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.generateString);
+    }
+}
+exports.GenerateRandomStringAction = GenerateRandomStringAction;
+GenerateRandomStringAction.mablScriptStepNames = ['generate_random_string'];
+GenerateRandomStringAction.yamlMablScriptNames = ['GenerateRandomString'];

package/mablscript/actions/GetUrlAction.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetUrlAction = void 0;
+const MablAction_1 = require("../MablAction");
+const GetCurrentLocationDescriptor_1 = require("../types/GetCurrentLocationDescriptor");
+class GetUrlAction extends MablAction_1.MablAction {
+    constructor(name, args) {
+        super(name, 'get_current_location', args);
+    }
+    toMablscript() {
+        return `get_current_location()`;
+    }
+    toDescriptor() {
+        return (0, GetCurrentLocationDescriptor_1.newGetCurrentLocationDescriptor)();
+    }
+    generateFindMablscript() {
+        return 'get_current_location()';
+    }
+}
+exports.GetUrlAction = GetUrlAction;
+GetUrlAction.mablScriptStepNames = ['get_current_location'];
+GetUrlAction.yamlMablScriptNames = ['GetUrl'];

package/mablscript/actions/GetVariableValue.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetVariableValue = void 0;
+const MablAction_1 = require("../MablAction");
+const MablSymbol_1 = require("../MablSymbol");
+const GetVariableDescriptor_1 = require("../types/GetVariableDescriptor");
+class GetVariableValue extends MablAction_1.MablAction {
+    constructor(name, args) {
+        super(name, 'get_variable_value', args);
+        const arg = this.getActionArgs()[0];
+        if (typeof arg !== 'string') {
+            throw new Error('Expected string argument');
+        }
+        this.variable = MablSymbol_1.MablSymbol.fromString(arg);
+    }
+    toMablscript() {
+        return `get_variable_value(${this.subVariable(this.variable.toString())})`;
+    }
+    toDescriptor() {
+        return (0, GetVariableDescriptor_1.newGetVariableDescriptor)(this.variable);
+    }
+    generateFindMablscript() {
+        return `get_variable_value(${this.variable.name})`;
+    }
+    getInputVariables() {
+        return MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.variable);
+    }
+}
+exports.GetVariableValue = GetVariableValue;
+GetVariableValue.mablScriptStepNames = ['get_variable_value'];
+GetVariableValue.yamlMablScriptNames = ['GetVariableValueAs'];

package/mablscript/actions/GetViewportAction.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetViewportAction = void 0;
+const MablAction_1 = require("../MablAction");
+const GetViewportDescriptor_1 = require("../types/GetViewportDescriptor");
+class GetViewportAction extends MablAction_1.MablAction {
+    constructor() {
+        super('get_viewport', 'get_viewport', []);
+    }
+    toDescriptor() {
+        return (0, GetViewportDescriptor_1.newGetViewportDescriptor)();
+    }
+    generateFindMablscript() {
+        return '';
+    }
+}
+exports.GetViewportAction = GetViewportAction;

package/mablscript/actions/JavaScriptAction.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJavaScriptActionDescriptor = exports.JavaScriptAction = void 0;
+const domUtil_1 = require("../../domUtil");
+const MablAction_1 = require("../MablAction");
+const SnippetsDescriptor_1 = require("../types/SnippetsDescriptor");
+const MABLSCRIPT_NAME = 'evaluate_js';
+function isLegacySnippetReference(value) {
+    return typeof value === 'object' && !!value.id && !('invariant_id' in value);
+}
+function isReusableSnippetReference(value) {
+    return typeof value === 'object' && !!value.id && !!value.invariant_id;
+}
+function isInlineSnippetReference(value) {
+    return (typeof value === 'object' &&
+        typeof value.body === 'string' &&
+        Array.isArray(value.parameters) &&
+        !('id' in value) &&
+        !('invariant_id' in value));
+}
+function isSnippetOptions(value) {
+    return value && 'parameter_overrides' in value;
+}
+class JavaScriptAction extends MablAction_1.MablAction {
+    constructor(name, args) {
+        super(name, MABLSCRIPT_NAME, args);
+        if (args.length < 1 || args.length > 2) {
+            throw new Error('EvaluateJS action expects 1 or 2 arguments');
+        }
+        const scriptOrSnippetReference = args[0];
+        if (!scriptOrSnippetReference ||
+            !(typeof scriptOrSnippetReference === 'string' ||
+                typeof scriptOrSnippetReference === 'object')) {
+            throw new Error('EvaluateJS action expects the first argument to be a string or object');
+        }
+        if (typeof scriptOrSnippetReference === 'string') {
+            this.javaScript = {
+                encodedJS: scriptOrSnippetReference,
+                actionCode: MABLSCRIPT_NAME,
+            };
+        }
+        else if (isLegacySnippetReference(scriptOrSnippetReference)) {
+            const { id } = scriptOrSnippetReference;
+            this.javaScript = {
+                snippetInvariantId: id,
+                actionCode: MABLSCRIPT_NAME,
+            };
+        }
+        else if (isReusableSnippetReference(scriptOrSnippetReference)) {
+            const { id, invariant_id } = scriptOrSnippetReference;
+            this.javaScript = {
+                snippetId: id,
+                snippetInvariantId: invariant_id,
+                parameterOverrides: [],
+                actionCode: MABLSCRIPT_NAME,
+            };
+            const snippetOptions = args[1];
+            if (isSnippetOptions(snippetOptions)) {
+                this.javaScript.parameterOverrides = snippetOptions.parameter_overrides;
+            }
+        }
+        else if (isInlineSnippetReference(scriptOrSnippetReference)) {
+            this.javaScript = {
+                inlineSnippet: scriptOrSnippetReference,
+                parameterOverrides: [],
+                actionCode: MABLSCRIPT_NAME,
+            };
+            const snippetOptions = args[1];
+            if (isSnippetOptions(snippetOptions)) {
+                this.javaScript.parameterOverrides = snippetOptions.parameter_overrides;
+            }
+        }
+        else {
+            throw new Error(`Invalid argument for EvaluateJS action: ${JSON.stringify(scriptOrSnippetReference)}`);
+        }
+    }
+    toDescriptor() {
+        return { javaScript: this.javaScript, actionCode: this.actionCode };
+    }
+    static fromDescriptor(descriptor) {
+        const { javaScript } = descriptor;
+        if ((0, SnippetsDescriptor_1.isReusableSnippetDescriptor)(javaScript)) {
+            return new JavaScriptAction(JavaScriptAction.mablscriptName, [
+                {
+                    id: javaScript.snippetId,
+                    invariant_id: javaScript.snippetInvariantId,
+                },
+                { parameter_overrides: javaScript.parameterOverrides },
+            ]);
+        }
+        else if ((0, SnippetsDescriptor_1.isInlineSnippetDescriptor)(javaScript)) {
+            return new JavaScriptAction(JavaScriptAction.mablscriptName, [
+                javaScript.inlineSnippet,
+                { parameter_overrides: javaScript.parameterOverrides },
+            ]);
+        }
+        else if ((0, SnippetsDescriptor_1.isLegacyReusableSnippetDescriptor)(javaScript)) {
+            return new JavaScriptAction(JavaScriptAction.mablscriptName, [
+                {
+                    id: javaScript.snippetInvariantId,
+                },
+            ]);
+        }
+        else if ((0, SnippetsDescriptor_1.isLegacyInlineJavaScriptDescriptor)(javaScript)) {
+            return new JavaScriptAction(JavaScriptAction.mablscriptName, [
+                javaScript.encodedJS,
+            ]);
+        }
+        throw new Error(`Invalid javascript action descriptor: ${JSON.stringify(descriptor)}`);
+    }
+    toYaml() {
+        return JavaScriptAction.toYamlFromJavaScriptDescriptor(this.javaScript);
+    }
+    static toYamlFromJavaScriptDescriptor(javaScript) {
+        const actionYaml = {};
+        if ((0, SnippetsDescriptor_1.isReusableSnippetDescriptor)(javaScript)) {
+            actionYaml.snippetId = javaScript.snippetId;
+            actionYaml.snippetInvariantId = javaScript.snippetInvariantId;
+            actionYaml.parameterOverrides = javaScript.parameterOverrides;
+        }
+        else if ((0, SnippetsDescriptor_1.isInlineSnippetDescriptor)(javaScript)) {
+            actionYaml.snippet = { ...actionYaml, ...javaScript.inlineSnippet };
+            actionYaml.parameterOverrides = javaScript.parameterOverrides;
+        }
+        else if ((0, SnippetsDescriptor_1.isLegacyReusableSnippetDescriptor)(javaScript)) {
+            actionYaml.snippetId = javaScript.snippetInvariantId;
+        }
+        else if ((0, SnippetsDescriptor_1.isLegacyInlineJavaScriptDescriptor)(javaScript)) {
+            actionYaml.code = javaScript.encodedJS;
+        }
+        else {
+            throw new Error(`Cannot export action to yaml: ${JSON.stringify(javaScript)}`);
+        }
+        return actionYaml;
+    }
+    static fromYaml(formatted) {
+        let snippetOptions;
+        if (formatted.parameterOverrides) {
+            snippetOptions = {
+                parameter_overrides: formatted.parameterOverrides,
+            };
+        }
+        const args = [];
+        if (formatted.code) {
+            args.push(formatted.code);
+        }
+        else if (formatted.body) {
+            delete formatted.parameterOverrides;
+            args.push(formatted);
+        }
+        else if (formatted.snippet) {
+            args.push(formatted.snippet);
+        }
+        else if (formatted.snippetInvariantId && formatted.snippetId) {
+            args.push({
+                id: formatted.snippetId,
+                invariant_id: formatted.snippetInvariantId,
+            });
+        }
+        else if (formatted.snippetId) {
+            args.push({
+                id: formatted.snippetId,
+            });
+        }
+        else {
+            throw new Error(`Cannot import action from yaml: ${JSON.stringify(formatted)}`);
+        }
+        if (snippetOptions) {
+            args.push(snippetOptions);
+        }
+        return new JavaScriptAction(MABLSCRIPT_NAME, args);
+    }
+    toMablscript() {
+        if ((0, SnippetsDescriptor_1.isReusableSnippetDescriptor)(this.javaScript)) {
+            const snippetReference = (0, domUtil_1.buildStepArgumentString)({
+                params: {
+                    id: this.javaScript.snippetId,
+                    invariant_id: this.javaScript.snippetInvariantId,
+                    snippet_type: 'javascript',
+                },
+                legacy: true,
+            });
+            const snippetOptions = `, {parameter_overrides: ${(0, domUtil_1.buildStepArgumentString)({ params: this.javaScript.parameterOverrides, legacy: true })}}`;
+            return `evaluate_js(${snippetReference}${snippetOptions})`;
+        }
+        if ((0, SnippetsDescriptor_1.isInlineSnippetDescriptor)(this.javaScript)) {
+            const snippetReference = (0, domUtil_1.buildStepArgumentString)({
+                params: { ...this.javaScript.inlineSnippet, snippet_type: 'javascript' },
+                legacy: true,
+            });
+            const snippetOptions = `, {parameter_overrides: ${(0, domUtil_1.buildStepArgumentString)({
+                params: this.javaScript.parameterOverrides,
+                legacy: true,
+            })}}`;
+            return `evaluate_js(${snippetReference}${snippetOptions})`;
+        }
+        if ((0, SnippetsDescriptor_1.isLegacyReusableSnippetDescriptor)(this.javaScript)) {
+            return `evaluate_js({id: "${this.javaScript.snippetInvariantId}", snippet_type: "javascript"})`;
+        }
+        if ((0, SnippetsDescriptor_1.isLegacyInlineJavaScriptDescriptor)(this.javaScript)) {
+            return `evaluate_js("${this.javaScript.encodedJS}")`;
+        }
+        throw new Error(`Cannot export action to mablscript: ${JSON.stringify(this.javaScript)}`);
+    }
+    getInputVariables() {
+        if ((0, SnippetsDescriptor_1.isInlineSnippetDescriptor)(this.javaScript) ||
+            (0, SnippetsDescriptor_1.isReusableSnippetDescriptor)(this.javaScript)) {
+            return MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.javaScript.parameterOverrides.map((override) => override.value));
+        }
+        return [];
+    }
+}
+exports.JavaScriptAction = JavaScriptAction;
+JavaScriptAction.mablscriptName = MABLSCRIPT_NAME;
+JavaScriptAction.mablScriptStepNames = [MABLSCRIPT_NAME];
+function isJavaScriptActionDescriptor(value) {
+    return value.javaScript !== undefined;
+}
+exports.isJavaScriptActionDescriptor = isJavaScriptActionDescriptor;