"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.EachAction = void 0;
const index_js_1 = require("../model/index.js");
const util = __importStar(require("../util/index.js"));
class EachAction extends index_js_1.Action {
    constructor() {
        super(...arguments);
        this.staticScope = false;
        this.$iteration = null;
        this.$elements = null;
    }
    reset() {
        super.reset();
        this.$iteration = null;
        this.$elements = null;
    }
    hasChildren() {
        return true;
    }
    async resolveChildrenScope() {
        const el = await this.getCurrentElement();
        util.assertPlayback(el, 'No iteration scope');
        return [el];
    }
    async exec() {
        this.nextIndex();
        const el = await this.getCurrentElement();
        this.$runtime.bypassed = !el;
    }
    afterRun() {
        if (this.$runtime.bypassed) {
            this.skip();
        }
        else {
            this.enter();
        }
    }
    leave() {
        this.$script.setPlayhead(this);
    }
    async getCurrentElement() {
        const elements = await this.captureScope();
        return this.$iteration == null ? null : elements[this.$iteration];
    }
    async captureScope() {
        if (this.staticScope && this.$elements != null) {
            return this.$elements;
        }
        const elements = await this.retry(() => this.selectAll(this.pipeline));
        if (this.staticScope) {
            this.$elements = elements;
        }
        return elements;
    }
    nextIndex() {
        this.$iteration = this.$iteration == null ? 0 : this.$iteration + 1;
    }
}
EachAction.$type = 'Flow.each';
EachAction.$icon = 'fas fa-list';
EachAction.$help = `
Iterates over a set of elements, passing control to children and modifying their scope.

The pipeline should resolve to a list of elements.
On every run the internal index is incremented, and the element at current index becomes the scope of children.

After last child is executed, the control is passed back to Each.
Each exits when there are no more elements left to iterate over.

Note: every time the children are executed the scope is re-evaluated;
specifically, if scope element disappears (or some other pipeline failure occurs),
then children won't be able to execute.

### Use For

- iterating over web page elements (e.g. passenger forms)
- executing actions per each item of the array
`;
__decorate([
    index_js_1.params.Pipeline(),
    __metadata("design:type", index_js_1.Pipeline)
], EachAction.prototype, "pipeline", void 0);
__decorate([
    index_js_1.params.Boolean(),
    __metadata("design:type", Boolean)
], EachAction.prototype, "staticScope", void 0);
exports.EachAction = EachAction;
//# sourceMappingURL=Flow.each.js.map