@mablhq/mabl-cli 1.17.6 → 1.18.3

package/execution/index.js.LICENSE.txt

@@ -168,6 +168,8 @@ PERFORMANCE OF THIS SOFTWARE.
  * code.
  */
 
+/*! js-yaml 4.1.0 https://github.com/nodeca/js-yaml @license MIT */
+
 /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
 
 /**

package/index.d.ts

@@ -24,7 +24,6 @@ declare module '@mablhq/mabl-cli' {
   }
   export enum RunnerType {
     Playwright = 'playwright',
-    Puppeteer = 'puppeteer',
   }
   export interface HttpHeadersType {
     [key: string]: string;

package/mablscript/MablAction.js

@@ -23,7 +23,7 @@ class MablAction {
                 return matches[1];
             }
         }
-        return `"${argument}"`;
+        return `${argument}`;
     }
     getActionName() {
         return this.name;

package/mablscript/MablStep.js

@@ -1,10 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildObjectString = exports.buildSourceRepresentationOfObject = exports.MablStep = void 0;
+const domUtil_1 = require("../domUtil");
 const MablAction_1 = require("./MablAction");
-const SeleniumIdeStep_1 = require("./steps/SeleniumIdeStep");
 const MablSymbol_1 = require("./MablSymbol");
-const domUtil_1 = require("../domUtil");
+const SeleniumIdeStep_1 = require("./steps/SeleniumIdeStep");
+const fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
 class MablStep extends MablAction_1.MablAction {
     constructor(name, args, actions) {
         super(name, args);
@@ -25,9 +29,15 @@ class MablStep extends MablAction_1.MablAction {
     setAnnotation(annotation) {
         this.annotation = annotation;
     }
+    getAnnotation() {
+        return this.annotation;
+    }
     setDescription(description) {
         this.description = description;
     }
+    getDescription() {
+        return this.description;
+    }
     setStepSourceIndexInFlow(index) {
         this.stepSourceIndexInFlow = index;
     }
@@ -102,7 +112,7 @@ class MablStep extends MablAction_1.MablAction {
                 case 'number':
                     return `${key}: ${objectArgs[key]}`;
                 default:
-                    return `${key}: "${objectArgs[key]}"`;
+                    return `${key}: "${(0, domUtil_1.escapeMablscriptString)(objectArgs[key])}"`;
             }
         });
         return `{${mablArgs.join(', ')}}`;
@@ -110,6 +120,14 @@ class MablStep extends MablAction_1.MablAction {
     toMablscript() {
         return '';
     }
+    toLineDiffFormat() {
+        const lineDiffProperties = {
+            annotation: this.annotation,
+            disabled: this.isDisabled(),
+            mablscript: this.toMablscript(),
+        };
+        return (0, fast_json_stable_stringify_1.default)(lineDiffProperties);
+    }
 }
 exports.MablStep = MablStep;
 MablStep.mablScriptStepNames = ['mablStep'];

package/mablscript/actions/AwaitPDFDownloadAction.js

@@ -2,13 +2,14 @@
 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({uuid: \"${this.pdfUUID}\"})`;
+        return `await_pdf(${(0, domUtil_1.buildStepArgumentString)({ uuid: this.pdfUUID })})`;
     }
 }
 exports.AwaitPDFDownloadAction = AwaitPDFDownloadAction;

package/mablscript/actions/ConditionAction.js

@@ -1,6 +1,7 @@
 "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 {
@@ -48,9 +49,16 @@ class ConditionAction extends MablAction_1.MablAction {
         };
     }
     generateEvaluateConditionMablscript() {
-        return `${this.name}("${this.conditionAttribute}"${this.conditionValueAttribute !== undefined
-            ? `, ${this.subVariable(this.conditionValueAttribute)}`
-            : ''})`;
+        let value = '';
+        if (this.conditionValueAttribute !== undefined) {
+            if (!(0, MablAction_1.argumentIsMablVariable)(this.conditionValueAttribute)) {
+                value = `, "${(0, domUtil_1.escapeMablscriptString)(this.conditionValueAttribute)}"`;
+            }
+            else {
+                value = `, ${this.subVariable(this.conditionValueAttribute)}`;
+            }
+        }
+        return `${this.name}("${this.conditionAttribute}"${value})`;
     }
     toMablscript() {
         return `${this.generateEvaluateConditionMablscript()}`;

package/mablscript/actions/ExtractAction.js

@@ -6,21 +6,26 @@ const ExtractDescriptor_1 = require("../types/ExtractDescriptor");
 class ExtractAction extends MablAction_1.MablAction {
     constructor(name, args) {
         super(name, args);
+        if (this.name === ExtractDescriptor_1.ExtractType.EXTRACT_INNER_TEXT) {
+            this.name = 'extract_attribute';
+            this.extractionAttribute = 'innerText';
+        }
+        else {
+            this.extractionAttribute = this.getActionArgs()[0];
+        }
         this.extractionType = this.name;
-        this.extractionAttribute = this.getActionArgs()[0];
         this.extractDescriptor = this.getExtractDescriptor();
     }
     getExtractDescriptor() {
-        const attributeName = this.args[0];
-        if (!attributeName) {
+        if (!this.extractionAttribute) {
             throw new Error(`Attribute name is required for extract attribute action.`);
         }
-        if (typeof attributeName !== 'string') {
-            throw new Error(`Invalid attribute provided for extract attribute extractor: ${attributeName}`);
+        if (typeof this.extractionAttribute !== 'string') {
+            throw new Error(`Invalid attribute provided for extract attribute extractor: ${this.extractionAttribute}`);
         }
         return {
             extractType: ExtractDescriptor_1.ExtractType.fromString(this.name),
-            attributeName,
+            attributeName: this.extractionAttribute,
         };
     }
     toMablscript() {
@@ -31,7 +36,11 @@ class ExtractAction extends MablAction_1.MablAction {
     }
 }
 exports.ExtractAction = ExtractAction;
-ExtractAction.mablScriptStepNames = ['extract_attribute', 'extract_email_attribute'];
+ExtractAction.mablScriptStepNames = [
+    'extract_attribute',
+    'extract_email_attribute',
+    'extract_inner_text',
+];
 ExtractAction.mablscriptToYamlType = {
     extract_attribute: 'ElementAttribute',
     extract_email_attribute: 'EmailAttribute',

package/mablscript/actions/FindAction.js

@@ -2,9 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalize = exports.isElementSelector = exports.FindAction = exports.findTypesToFormattedType = void 0;
 const domUtil_1 = require("../../domUtil");
-const MablAction_1 = require("../MablAction");
 const mablscriptFind_1 = require("../../mablscriptFind");
-const MablStep_1 = require("../MablStep");
+const MablAction_1 = require("../MablAction");
 exports.findTypesToFormattedType = {
     find_all: 'FindAll',
     find_any: 'FindFirst',
@@ -13,6 +12,7 @@ exports.findTypesToFormattedType = {
     find_one: 'FindOne',
     find_email: 'FindEmail',
     find_tab: 'FindTab',
+    find_last: 'FindLast',
 };
 const formattedFindTypeToMablscript = {};
 Object.entries(exports.findTypesToFormattedType).forEach(([findType, field]) => (formattedFindTypeToMablscript[field] = findType));
@@ -24,10 +24,10 @@ class FindAction extends MablAction_1.MablAction {
             throw new Error(`Unknown find type for action: ${actionName}`);
         }
         const findType = domUtil_1.FindType.fromString(actionName);
-        const [selectors, options] = this.getActionArgs();
         this.isValid = true;
         switch (findType) {
-            case domUtil_1.FindType.FIND_ONE:
+            case domUtil_1.FindType.FIND_ONE: {
+                const [selectors, options] = this.getActionArgs();
                 if (!isElementSelector(selectors)) {
                     this.isValid = false;
                 }
@@ -46,19 +46,30 @@ class FindAction extends MablAction_1.MablAction {
                     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:
-                if (!(0, domUtil_1.isCssSelector)(selectors) && !(0, domUtil_1.isXPathSelector)(selectors)) {
+            case domUtil_1.FindType.FIND_ALL: {
+                const [primarySelector, foundSelector, findOptions] = this.getActionArgs();
+                if (!(0, domUtil_1.isCssSelector)(primarySelector) &&
+                    !(0, domUtil_1.isXPathSelector)(primarySelector)) {
                     this.isValid = false;
                 }
                 this.findDescriptor = {
                     findType,
-                    findTarget: selectors,
+                    findTarget: primarySelector,
+                    foundElementSelectors: foundSelector,
+                    primarySelectors: {
+                        ...primarySelector,
+                        uuid: primarySelector.uuid,
+                    },
+                    hints: findOptions === null || findOptions === void 0 ? void 0 : findOptions.hints,
                 };
                 break;
-            case domUtil_1.FindType.FIND_COOKIE:
+            }
+            case domUtil_1.FindType.FIND_COOKIE: {
+                const [selectors] = this.getActionArgs();
                 if (!(0, domUtil_1.isCookieSelector)(selectors)) {
                     this.isValid = false;
                 }
@@ -67,7 +78,9 @@ class FindAction extends MablAction_1.MablAction {
                     findTarget: selectors,
                 };
                 break;
+            }
             case domUtil_1.FindType.FIND_EMAIL:
+                const [selectors] = this.getActionArgs();
                 if (!(0, domUtil_1.isEmailSelector)(selectors)) {
                     this.isValid = false;
                 }
@@ -76,7 +89,8 @@ class FindAction extends MablAction_1.MablAction {
                     findTarget: selectors,
                 };
                 break;
-            case domUtil_1.FindType.FIND_TAB:
+            case domUtil_1.FindType.FIND_TAB: {
+                const [selectors] = this.getActionArgs();
                 if (selectors !== 'initial' && !(0, domUtil_1.isTabSelector)(selectors)) {
                     this.isValid = false;
                 }
@@ -84,6 +98,7 @@ class FindAction extends MablAction_1.MablAction {
                     findType,
                     findTarget: selectors,
                 };
+            }
         }
         Object.freeze(this.findDescriptor);
     }
@@ -155,47 +170,71 @@ class FindAction extends MablAction_1.MablAction {
         }
     }
     toMablscript() {
-        return this.generateMablscriptFindOne();
+        return this.generateFindMablscript();
     }
-    generateMablscriptFindOne() {
+    generateFindMablscript() {
         var _a;
+        let action = this.findDescriptor.findType;
+        let args = '';
         switch (this.findDescriptor.findType) {
-            case domUtil_1.FindType.FIND_ONE: {
+            case domUtil_1.FindType.FIND_ONE:
                 const find = this.findDescriptor;
-                const action = find.findType;
                 const selectors = ((_a = find.findTarget.auxiliaryDescriptors) === null || _a === void 0 ? void 0 : _a.length)
                     ? '[' +
-                        [
-                            find.findTarget.selector,
-                            ...find.findTarget.auxiliaryDescriptors.map((descriptor) => descriptor.selector),
-                        ]
-                            .map(mablscriptFind_1.buildElementSelectorString)
+                        [find.findTarget, ...find.findTarget.auxiliaryDescriptors]
+                            .map(mablscriptFind_1.buildFindDescriptorString)
+                            .filter(Boolean)
                             .join(', ') +
                         ']'
-                    : (0, mablscriptFind_1.buildElementSelectorString)(find.findTarget.selector);
+                    : (0, mablscriptFind_1.buildFindDescriptorString)(find.findTarget);
                 const options = buildFindOptionsString(find.findOptions);
-                const args = [selectors, options].filter((str) => str).join(', ');
-                return `${action}(${args})`;
-            }
-            case domUtil_1.FindType.FIND_FIRST:
+                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"}';
+                }
+                args = [selector, foundElementSelectors].join(', ');
+                if (find.hints) {
+                    args += `, ${(0, mablscriptFind_1.buildFindHintsString)(find.hints)}`;
+                }
+                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: {
-                const find = this.findDescriptor;
-                const action = find.findType;
-                const args = (0, mablscriptFind_1.buildElementSelectorString)(find.findTarget);
-                return `${action}(${args})`;
+                args = (0, mablscriptFind_1.buildEmailSelectorString)(this.findDescriptor.findTarget);
+                break;
             }
             case domUtil_1.FindType.FIND_TAB:
-                if (this.findDescriptor.findTarget === 'initial') {
-                    return `${this.findDescriptor.findType}("${this.findDescriptor.findTarget}")`;
-                }
-                return `${this.findDescriptor.findType}(${(0, mablscriptFind_1.buildElementSelectorString)(this.findDescriptor.findTarget)})`;
+                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;
@@ -226,15 +265,7 @@ function buildFindOptionsString(findOptions) {
     if (!findOptions) {
         return '';
     }
-    let findOptionsFinal = '{';
-    if (findOptions.hints) {
-        findOptionsFinal += `hints: {${(0, MablStep_1.buildObjectString)(findOptions.hints).join(', ')}}`;
-    }
-    if (findOptions.waitUntil) {
-        findOptionsFinal += `waitUntil: {${(0, MablStep_1.buildObjectString)(findOptions.waitUntil)}}`;
-    }
-    findOptionsFinal += '}';
-    return findOptionsFinal;
+    return JSON.stringify(findOptions);
 }
 function isElementSelector(maybeSelectors) {
     const [target, ancestor] = Array.isArray(maybeSelectors)

package/mablscript/actions/GenerateRandomStringAction.js

@@ -2,13 +2,14 @@
 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, args);
         this.generateString = this.getActionArgs()[0];
     }
     toMablscript() {
-        return `generate_random_string(\"${this.generateString}\")`;
+        return `generate_random_string(\"${(0, domUtil_1.escapeMablscriptString)(this.generateString)}\")`;
     }
 }
 exports.GenerateRandomStringAction = GenerateRandomStringAction;

package/mablscript/actions/GetUrlAction.js

@@ -13,7 +13,7 @@ class GetUrlAction extends MablAction_1.MablAction {
     toDescriptor() {
         return (0, GetCurrentLocationDescriptor_1.newGetCurrentLocationDescriptor)();
     }
-    generateMablscriptFindOne() {
+    generateFindMablscript() {
         return 'get_current_location()';
     }
 }

package/mablscript/actions/GetVariableValue.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetVariableValue = void 0;
 const MablAction_1 = require("../MablAction");
-const GetVariableDescriptor_1 = require("../types/GetVariableDescriptor");
 const MablSymbol_1 = require("../MablSymbol");
+const GetVariableDescriptor_1 = require("../types/GetVariableDescriptor");
 class GetVariableValue extends MablAction_1.MablAction {
     constructor(name, args) {
         super(name, args);
@@ -19,7 +19,7 @@ class GetVariableValue extends MablAction_1.MablAction {
     toDescriptor() {
         return (0, GetVariableDescriptor_1.newGetVariableDescriptor)(this.variable);
     }
-    generateMablscriptFindOne() {
+    generateFindMablscript() {
         return `get_variable_value(${this.variable.name})`;
     }
 }

package/mablscript/diffing/diffingUtil.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffFlows = exports.diffTests = exports.convertDiffingFormatIntoDiffingSteps = exports.flattenTestFlowsIntoLineDiffingFormat = exports.convertFlowToStepList = exports.lineModeDiff = exports.DiffOperation = void 0;
+const mablApi_1 = require("../../mablApi");
+const importer_1 = require("../importer");
+const EvaluateFlowStep_1 = require("../steps/EvaluateFlowStep");
+const diffPatchMatch_1 = __importDefault(require("./diffPatchMatch"));
+const fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
+var DiffOperation;
+(function (DiffOperation) {
+    DiffOperation["DELETE"] = "DELETE";
+    DiffOperation["EQUAL"] = "EQUAL";
+    DiffOperation["INSERT"] = "INSERT";
+})(DiffOperation = exports.DiffOperation || (exports.DiffOperation = {}));
+function lineModeDiff(text1, text2) {
+    const dmp = new diffPatchMatch_1.default();
+    const lineToCharDiff = dmp.diff_linesToChars(text1, text2);
+    const lineText1 = lineToCharDiff.chars1;
+    const lineText2 = lineToCharDiff.chars2;
+    const lineArray = lineToCharDiff.lineArray;
+    const diffs = dmp.diff_main(lineText1, lineText2, false);
+    dmp.diff_charsToLines(diffs, lineArray);
+    const typedDiff = diffs.map((diff) => ({
+        operation: convertOperationValue(diff[0]),
+        text: diff[1],
+    }));
+    return typedDiff;
+}
+exports.lineModeDiff = lineModeDiff;
+function convertOperationValue(op) {
+    switch (op) {
+        case -1:
+            return DiffOperation.DELETE;
+        case 0:
+            return DiffOperation.EQUAL;
+        case 1:
+            return DiffOperation.INSERT;
+        default:
+            return DiffOperation.EQUAL;
+    }
+}
+function convertFlowToStepList(flow, flowConfig) {
+    if (!flow.reusable && flow.flow_type === mablApi_1.Flow.FlowTypeEnum.Mablscript) {
+        return (0, importer_1.parseMablScriptIntoSteps)(flow);
+    }
+    const evaluateFlowStep = new EvaluateFlowStep_1.EvaluateFlowStep(EvaluateFlowStep_1.EvaluateFlowStep.mablScriptStepNames[0], [
+        {
+            invariant_id: flow === null || flow === void 0 ? void 0 : flow.invariant_id,
+        },
+        flowConfig,
+    ], []);
+    if (flow.description) {
+        evaluateFlowStep.setDescription(flow.description);
+    }
+    return [evaluateFlowStep];
+}
+exports.convertFlowToStepList = convertFlowToStepList;
+function flattenTestFlowsIntoSteps(flows, flowConfig) {
+    return flows.flatMap((flow, index) => convertFlowToStepList(flow, flowConfig === null || flowConfig === void 0 ? void 0 : flowConfig[index]));
+}
+function flattenTestFlowsIntoLineDiffingFormat(flows, flowConfig) {
+    const flattenedSteps = flattenTestFlowsIntoSteps(flows, flowConfig);
+    const diffingFormat = flattenedSteps
+        .map((step) => step.toLineDiffFormat())
+        .join('\n');
+    return { flattenedSteps, diffingFormat };
+}
+exports.flattenTestFlowsIntoLineDiffingFormat = flattenTestFlowsIntoLineDiffingFormat;
+function convertDiffingFormatIntoDiffingSteps(diffs, sourceSteps, targetSteps) {
+    const leftSteps = [...sourceSteps];
+    const rightSteps = [...targetSteps];
+    leftSteps.forEach((step) => {
+        step.setStepSourceIndexInFlow(0);
+    });
+    rightSteps.forEach((step) => {
+        step.setStepSourceIndexInFlow(0);
+    });
+    const stepDiffs = diffs.map((diff) => {
+        const lineDiffs = diff.text.trim().split('\n');
+        const stepDiffCount = lineDiffs.length;
+        let steps = [];
+        switch (diff.operation) {
+            case DiffOperation.EQUAL:
+                steps = leftSteps.splice(0, stepDiffCount);
+                rightSteps.splice(0, stepDiffCount);
+                break;
+            case DiffOperation.INSERT:
+                steps = rightSteps.splice(0, stepDiffCount);
+                break;
+            case DiffOperation.DELETE:
+                steps = leftSteps.splice(0, stepDiffCount);
+                break;
+        }
+        return {
+            operation: diff.operation,
+            steps,
+        };
+    });
+    return stepDiffs;
+}
+exports.convertDiffingFormatIntoDiffingSteps = convertDiffingFormatIntoDiffingSteps;
+function diffTests(test1Flows, test1FlowConfig, test2Flows, test2FlowConfig) {
+    const { flattenedSteps: flattenedTest1Steps, diffingFormat: test1DiffingFormat, } = flattenTestFlowsIntoLineDiffingFormat(test1Flows, test1FlowConfig);
+    const { flattenedSteps: flattenedTest2Steps, diffingFormat: test2DiffingFormat, } = flattenTestFlowsIntoLineDiffingFormat(test2Flows, test2FlowConfig);
+    const diffs = lineModeDiff(test1DiffingFormat, test2DiffingFormat);
+    return convertDiffingFormatIntoDiffingSteps(diffs, flattenedTest1Steps, flattenedTest2Steps);
+}
+exports.diffTests = diffTests;
+function diffFlows(flow1, flow2) {
+    var _a, _b;
+    const flow1Steps = (0, importer_1.parseMablScriptIntoSteps)(flow1);
+    const formattedFlow1Steps = flow1Steps
+        .map((step) => step.toLineDiffFormat())
+        .join('\n');
+    const flow2Steps = (0, importer_1.parseMablScriptIntoSteps)(flow2);
+    const formattedFlow2Steps = flow2Steps
+        .map((step) => step.toLineDiffFormat())
+        .join('\n');
+    const flattenedDiffs = lineModeDiff(formattedFlow1Steps, formattedFlow2Steps);
+    const stepDiffs = convertDiffingFormatIntoDiffingSteps(flattenedDiffs, flow1Steps, flow2Steps);
+    const parametersDiff = diffFlowVariables(flow1.parameters, flow2.parameters);
+    const inputVariablesDiff = diffFlowVariables((_a = flow1.variables) === null || _a === void 0 ? void 0 : _a.inputs, (_b = flow2.variables) === null || _b === void 0 ? void 0 : _b.inputs);
+    return { stepDiff: stepDiffs, parametersDiff, inputVariablesDiff };
+}
+exports.diffFlows = diffFlows;
+function diffFlowVariables(flow1Variables, flow2Variables) {
+    const flow1VariablesFlattened = flattenFlowVariables(flow1Variables);
+    const flow2VariablesFlattened = flattenFlowVariables(flow2Variables);
+    const diffs = lineModeDiff(flow1VariablesFlattened, flow2VariablesFlattened);
+    const flowVariablesDiff = diffs.map((diff) => {
+        const variablesStringified = diff.text.trim().split('\n');
+        const reassembledVariables = variablesStringified.map((variablesText) => JSON.parse(variablesText));
+        return {
+            operation: diff.operation,
+            variables: reassembledVariables,
+        };
+    });
+    return flowVariablesDiff;
+}
+function flattenFlowVariables(flowVariables) {
+    var _a;
+    return ((_a = flowVariables === null || flowVariables === void 0 ? void 0 : flowVariables.sort((a, b) => a.name.localeCompare(b.name)).map((parameter) => (0, fast_json_stable_stringify_1.default)(parameter)).join('\n')) !== null && _a !== void 0 ? _a : '');
+}

package/mablscript/importer.js

@@ -51,6 +51,7 @@ const ReleaseStep_1 = require("./steps/ReleaseStep");
 const CountAction_1 = require("./actions/CountAction");
 const loggingProvider_1 = require("../providers/logging/loggingProvider");
 const AccessibilityCheck_1 = require("./steps/AccessibilityCheck");
+const EvaluateFlowStep_1 = require("./steps/EvaluateFlowStep");
 const ActionTypes = [
     AwaitDownloadAction_1.AwaitDownloadAction,
     AwaitPDFDownloadAction_1.AwaitPDFDownloadAction,
@@ -81,6 +82,7 @@ const StepTypes = [
     ElseIfConditionStep_1.ElseIfConditionStep,
     EndStep_1.EndStep,
     EnterTextStep_1.EnterTextStep,
+    EvaluateFlowStep_1.EvaluateFlowStep,
     HoverStep_1.HoverStep,
     IfConditionStep_1.IfConditionStep,
     EvaluateJavaScriptStep_1.EvaluateJavaScriptStep,
@@ -150,9 +152,12 @@ function loadMablScriptIntoSteps(parsedMablscript) {
             action.setActionSourceIndexInStep(actionIndex);
             return action;
         });
-        const step = stepType
+        let step = stepType
             ? new stepType(lastAction.name, lastAction.arguments, actions)
             : new MablStep_1.MablStep(lastAction.name, lastAction.arguments, actions);
+        if (step instanceof AssertStepOld_1.AssertStepOld) {
+            step = step.getNewAssertionStep();
+        }
         step.setActionSourceIndexInStep(actions.length);
         step.setStepSourceIndexInFlow(parseInt(stepIndexString));
         return step;
@@ -169,7 +174,7 @@ StepTypes.forEach((step) => {
     step.yamlMablScriptNames.forEach((name) => (yamlMablscriptToObjectsStepMap[name] = step.fromYaml));
 });
 function loadYamlSteps(yamlSteps) {
-    const loadedStepData = (0, js_yaml_1.safeLoad)(yamlSteps);
+    const loadedStepData = (0, js_yaml_1.load)(yamlSteps);
     return loadedStepData.map((stepObject) => {
         const stepName = Object.keys(stepObject)[0];
         const stepArgs = stepObject[stepName];
@@ -280,6 +285,19 @@ function parseObjectExpression(expression) {
         let key;
         let value;
         switch (property.value.type) {
+            case 'UnaryExpression':
+                key = property.key;
+                value = property.value;
+                const operator = value.operator;
+                const rawValue = Number(value.argument.raw);
+                if (operator === '-') {
+                    value = -Math.abs(rawValue);
+                }
+                else {
+                    throw Error(`Cannot parse UnaryExpression ${property}`);
+                }
+                finalObj[key.name] = value;
+                break;
             case 'Literal':
                 key =
                     property.key.type === 'Identifier'