"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.WhileAction = void 0;
const index_js_1 = require("../model/index.js");
const util = __importStar(require("../util/index.js"));
class WhileAction extends index_js_1.Action {
    constructor() {
        super(...arguments);
        this.limit = 10;
        this.$attempts = 0;
    }
    reset() {
        super.reset();
        this.$attempts = 0;
    }
    hasChildren() {
        return true;
    }
    async exec() {
        util.assertPlayback(this.$attempts <= this.limit, 'While loop limit exceeded');
        const condition = await this.retry(async () => {
            const el = await this.selectSingle(this.pipeline, false);
            const condition = el.value;
            util.checkType(condition, 'boolean');
            return condition;
        });
        this.$runtime.bypassed = !condition;
        this.$attempts += 1;
    }
    afterRun() {
        if (this.$runtime.bypassed) {
            this.skip();
        }
        else {
            this.enter();
        }
    }
    leave() {
        this.$script.setPlayhead(this);
    }
}
WhileAction.$type = 'Flow.while';
WhileAction.$icon = 'fas fa-sync-alt';
WhileAction.$help = `
Loops over child actions while the condition holds \`true\`.

The pipeline should resolve to a single element with boolean value.
If the value is \`true\`, the control is passed to children, otherwise the children are skipped.
After last child is executed, the control is passed back to While so that the condition could be checked again.

The scope of children is not modified by this pipeline (children will receive the scope from the parent of this action).

### Parameters

- limit: maximum number of iterations allowed (to prevent endless loops)

### Use For

- creating general purpose loops which execute actions whilst the condition is met
  (e.g. click button until something happens)
`;
__decorate([
    index_js_1.params.Pipeline(),
    __metadata("design:type", index_js_1.Pipeline)
], WhileAction.prototype, "pipeline", void 0);
__decorate([
    index_js_1.params.Number({ min: 0 }),
    __metadata("design:type", Number)
], WhileAction.prototype, "limit", void 0);
exports.WhileAction = WhileAction;
//# sourceMappingURL=Flow.while.js.map