@arquimedes.co/eureka-forms 3.0.31-test → 3.0.32

package/dist/App/AppFunctions.js

@@ -1,209 +1,368 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { nanoid } from 'nanoid';
-import FormStepTypes, { EntityValueOptionTypes, FormTypes } from '../constants/FormStepTypes';
+import FormStepTypes, { EntityValueOptionTypes, FormTypes, } from '../constants/FormStepTypes';
 import { getRawText, stringToDraft } from '../Utils/DraftFunctions';
 import ConditionTypes from '../constants/ConditionTypes';
 import widgetInstance from '../Utils/AxiosWidget';
 import { calcRecursiveData } from '../Utils/FormStepFunctions';
 import { getCountry } from 'react-international-phone';
 import { isValidPhoneNumber } from '../Utils/PhoneFunctions';
-export const calcValuesStore = async (orgInfo, form, originalValues = {}, postview = false, customSteps = {}) => {
-    const values = {
-        global: {},
-        sections: {},
-    };
-    await Promise.all(Object.keys(originalValues).map(async (idValue) => {
-        const step = form.steps[idValue];
-        if (step) {
-            const value = await mapOriginalValue(orgInfo, step, originalValues[step.id], values, form);
-            if (value !== undefined) {
-                if (!form.hiddenSteps?.includes(step.id)) {
-                    if (!values.sections[step.idSection])
-                        values.sections[step.idSection] = {};
-                    values.sections[step.idSection][step.id] = value;
-                }
-                else {
-                    values.global[idValue] = value;
-                }
+export var calcValuesStore = function (orgInfo, form, originalValues, postview, customSteps) {
+    if (originalValues === void 0) { originalValues = {}; }
+    if (postview === void 0) { postview = false; }
+    if (customSteps === void 0) { customSteps = {}; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var values, _i, _a, section, _b, _c, idStep, step, _d, element, mappers;
+        var _e;
+        var _f;
+        return __generator(this, function (_g) {
+            switch (_g.label) {
+                case 0:
+                    values = {
+                        global: {},
+                        sections: {},
+                    };
+                    return [4 /*yield*/, Promise.all(Object.keys(originalValues).map(function (idValue) { return __awaiter(void 0, void 0, void 0, function () {
+                            var step, value;
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        step = form.steps[idValue];
+                                        if (!step) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, mapOriginalValue(orgInfo, step, originalValues[step.id], values, form)];
+                                    case 1:
+                                        value = _b.sent();
+                                        if (value !== undefined) {
+                                            if (!((_a = form.hiddenSteps) === null || _a === void 0 ? void 0 : _a.includes(step.id))) {
+                                                if (!values.sections[step.idSection])
+                                                    values.sections[step.idSection] = {};
+                                                values.sections[step.idSection][step.id] = value;
+                                            }
+                                            else {
+                                                values.global[idValue] = value;
+                                            }
+                                        }
+                                        return [3 /*break*/, 3];
+                                    case 2:
+                                        values.global[idValue] = originalValues[idValue];
+                                        _b.label = 3;
+                                    case 3: return [2 /*return*/];
+                                }
+                            });
+                        }); }))];
+                case 1:
+                    _g.sent();
+                    if (postview)
+                        return [2 /*return*/, values];
+                    for (_i = 0, _a = Object.values(form.sections); _i < _a.length; _i++) {
+                        section = _a[_i];
+                        for (_b = 0, _c = section.steps; _b < _c.length; _b++) {
+                            idStep = _c[_b];
+                            step = form.steps[idStep];
+                            if (step.type !== FormStepTypes.MAPPER ||
+                                ((_f = values.sections[step.idSection]) === null || _f === void 0 ? void 0 : _f[step.id]))
+                                continue;
+                            if (!values.sections[step.idSection])
+                                values.sections[step.idSection] = {};
+                            _d = addMapperStep(step, customSteps), element = _d.element, mappers = _d.mappers;
+                            values.sections[step.idSection] = __assign(__assign(__assign({}, values.sections[step.idSection]), mappers), (_e = {}, _e[step.id] = { elements: [element], page: 0 }, _e));
+                        }
+                    }
+                    return [2 /*return*/, values];
             }
-        }
-        else {
-            values.global[idValue] = originalValues[idValue];
-        }
-    }));
-    if (postview)
-        return values;
-    for (const section of Object.values(form.sections)) {
-        for (const idStep of section.steps) {
-            const step = form.steps[idStep];
-            if (step.type !== FormStepTypes.MAPPER || values.sections[step.idSection]?.[step.id])
-                continue;
-            if (!values.sections[step.idSection])
-                values.sections[step.idSection] = {};
-            const { element, mappers } = addMapperStep(step, customSteps);
-            values.sections[step.idSection] = {
-                ...values.sections[step.idSection],
-                ...mappers,
-                [step.id]: { elements: [element], page: 0 },
-            };
-        }
-    }
-    return values;
+        });
+    });
 };
-export const addMapperStep = (step, customSteps, path = '') => {
-    const idElement = nanoid();
-    const element = {
+export var addMapperStep = function (step, customSteps, path) {
+    if (path === void 0) { path = ''; }
+    var idElement = nanoid();
+    var element = {
         ids: {},
         id: idElement,
         originalValues: {},
         isOriginal: false,
     };
-    let steps = {};
-    let mappers = {};
-    const base = path ? path + '-' : '';
-    for (const idStep of Object.keys(step.steps)) {
-        const baseStep = JSON.parse(JSON.stringify(step.steps[idStep]));
-        const newIdStep = base + step.id + '-' + idElement + '-' + idStep;
+    var steps = {};
+    var mappers = {};
+    var base = path ? path + '-' : '';
+    for (var _i = 0, _a = Object.keys(step.steps); _i < _a.length; _i++) {
+        var idStep = _a[_i];
+        var baseStep = JSON.parse(JSON.stringify(step.steps[idStep]));
+        var newIdStep = base + step.id + '-' + idElement + '-' + idStep;
         baseStep.id = newIdStep;
         element.ids[idStep] = newIdStep;
         steps[newIdStep] = baseStep;
     }
     calcRecursiveData(element, steps, customSteps);
-    for (const nestedStep of Object.values(step.steps)) {
+    for (var _b = 0, _c = Object.values(step.steps); _b < _c.length; _b++) {
+        var nestedStep = _c[_b];
         if (nestedStep.type === FormStepTypes.MAPPER) {
-            const nested = addMapperStep(nestedStep, customSteps, base + step.id + '-' + idElement);
-            steps = { ...steps, ...nested.steps };
-            mappers = { ...mappers, ...nested.mappers };
+            var nested = addMapperStep(nestedStep, customSteps, base + step.id + '-' + idElement);
+            steps = __assign(__assign({}, steps), nested.steps);
+            mappers = __assign(__assign({}, mappers), nested.mappers);
             mappers[element.ids[nestedStep.id]] = {
                 elements: [nested.element],
                 page: 0,
             };
         }
     }
-    return { element, mappers, steps };
+    return { element: element, mappers: mappers, steps: steps };
 };
-export const mapOriginalValue = async (orgInfo, step, value, values, form, path = '') => {
-    if (!value)
-        return value;
-    switch (step?.type) {
-        case FormStepTypes.MAPPER: {
-            const elements = value;
-            const mappedElements = [];
-            for (const element of elements) {
-                const idElement = element.id ?? nanoid();
-                const mappedElement = {
-                    id: idElement,
-                    ids: {},
-                    originalValues: {},
-                    isOriginal: true,
-                };
-                if (element.value) {
-                    mappedElement.value = element.value;
-                }
-                const base = path ? path + '-' : '';
-                await Promise.all(Object.keys(step.steps).map(async (idStep) => {
-                    const newIdStep = base + step.id + '-' + idElement + '-' + idStep;
-                    mappedElement.ids[idStep] = newIdStep;
-                    const value = await mapOriginalValue(orgInfo, step.steps[idStep], element[idStep], values, form, base + step.id + '-' + idElement);
-                    if (value !== undefined) {
-                        if (!values.sections[step.idSection])
-                            values.sections[step.idSection] = {};
-                        values.sections[step.idSection][newIdStep] = value;
+export var mapOriginalValue = function (orgInfo, step, value, values, form, path) {
+    if (path === void 0) { path = ''; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var _a, elements, mappedElements, _loop_1, _i, elements_1, element, defaultValue, option, stepClassifier, classifier, params, url, entityValues, entityValue, country;
+        var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        return __generator(this, function (_p) {
+            switch (_p.label) {
+                case 0:
+                    if (!value)
+                        return [2 /*return*/, value];
+                    _a = step === null || step === void 0 ? void 0 : step.type;
+                    switch (_a) {
+                        case FormStepTypes.MAPPER: return [3 /*break*/, 1];
+                        case FormStepTypes.TEXTAREA: return [3 /*break*/, 6];
+                        case FormStepTypes.SELECTOR: return [3 /*break*/, 7];
+                        case FormStepTypes.CLASSIFIER_SELECTOR: return [3 /*break*/, 8];
+                        case FormStepTypes.ENTITYVALUEPICKER: return [3 /*break*/, 9];
+                        case FormStepTypes.TEXTINPUT: return [3 /*break*/, 12];
+                    }
+                    return [3 /*break*/, 13];
+                case 1:
+                    elements = value;
+                    mappedElements = [];
+                    _loop_1 = function (element) {
+                        var idElement, mappedElement, base, _q, _r, subStep, dependencies, _s, dependencies_1, idDep, mappedIdDep, _t, _u, key;
+                        return __generator(this, function (_v) {
+                            switch (_v.label) {
+                                case 0:
+                                    idElement = (_b = element.id) !== null && _b !== void 0 ? _b : nanoid();
+                                    mappedElement = {
+                                        id: idElement,
+                                        ids: {},
+                                        originalValues: {},
+                                        isOriginal: true,
+                                    };
+                                    if (element.value) {
+                                        mappedElement.value = element.value;
+                                    }
+                                    base = path ? path + '-' : '';
+                                    return [4 /*yield*/, Promise.all(Object.keys(step.steps).map(function (idStep) { return __awaiter(void 0, void 0, void 0, function () {
+                                            var newIdStep, value;
+                                            return __generator(this, function (_a) {
+                                                switch (_a.label) {
+                                                    case 0:
+                                                        newIdStep = base + step.id + '-' + idElement + '-' + idStep;
+                                                        mappedElement.ids[idStep] = newIdStep;
+                                                        return [4 /*yield*/, mapOriginalValue(orgInfo, step.steps[idStep], element[idStep], values, form, base + step.id + '-' + idElement)];
+                                                    case 1:
+                                                        value = _a.sent();
+                                                        if (value !== undefined) {
+                                                            if (!values.sections[step.idSection])
+                                                                values.sections[step.idSection] = {};
+                                                            values.sections[step.idSection][newIdStep] = value;
+                                                        }
+                                                        return [2 /*return*/];
+                                                }
+                                            });
+                                        }); }))];
+                                case 1:
+                                    _v.sent();
+                                    for (_q = 0, _r = Object.values(step.steps); _q < _r.length; _q++) {
+                                        subStep = _r[_q];
+                                        dependencies = (_c = subStep.dependencies) !== null && _c !== void 0 ? _c : [];
+                                        if (subStep.condition) {
+                                            dependencies = __spreadArray(__spreadArray([], dependencies, true), calcNestedConditionSteps(subStep.condition), true).filter(function (item, i, ar) { return ar.indexOf(item) === i; });
+                                        }
+                                        for (_s = 0, dependencies_1 = dependencies; _s < dependencies_1.length; _s++) {
+                                            idDep = dependencies_1[_s];
+                                            mappedIdDep = base + step.id + '-' + idElement + '-' + idDep;
+                                            if (!values.sections[step.idSection][idDep] &&
+                                                !values.global[mappedIdDep] &&
+                                                element[idDep]) {
+                                                values.global[mappedIdDep] = element[idDep];
+                                                mappedElement.ids[idDep] = mappedIdDep;
+                                            }
+                                        }
+                                    }
+                                    for (_t = 0, _u = Object.keys(element); _t < _u.length; _t++) {
+                                        key = _u[_t];
+                                        if (step.steps[key] || key === 'id')
+                                            continue;
+                                        mappedElement.originalValues[key] = element[key];
+                                    }
+                                    mappedElements.push(mappedElement);
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _i = 0, elements_1 = elements;
+                    _p.label = 2;
+                case 2:
+                    if (!(_i < elements_1.length)) return [3 /*break*/, 5];
+                    element = elements_1[_i];
+                    return [5 /*yield**/, _loop_1(element)];
+                case 3:
+                    _p.sent();
+                    _p.label = 4;
+                case 4:
+                    _i++;
+                    return [3 /*break*/, 2];
+                case 5: return [2 /*return*/, { elements: mappedElements, page: 0 }];
+                case 6:
+                    {
+                        if (step.hasTextEditor) {
+                            if (typeof value === 'string') {
+                                return [2 /*return*/, stringToDraft(value)];
+                            }
+                            return [2 /*return*/, getRawText(value === null || value === void 0 ? void 0 : value.draft, value === null || value === void 0 ? void 0 : value.text)];
+                        }
+                        defaultValue = (_d = value.value) !== null && _d !== void 0 ? _d : value;
+                        if (typeof defaultValue === 'string') {
+                            return [2 /*return*/, defaultValue];
+                        }
+                        else {
+                            return [2 /*return*/, (_e = defaultValue === null || defaultValue === void 0 ? void 0 : defaultValue.text) !== null && _e !== void 0 ? _e : ''];
+                        }
                     }
-                }));
-                for (const subStep of Object.values(step.steps)) {
-                    let dependencies = subStep.dependencies ?? [];
-                    if (subStep.condition) {
-                        dependencies = [...dependencies, ...calcNestedConditionSteps(subStep.condition)].filter((item, i, ar) => ar.indexOf(item) === i);
+                    _p.label = 7;
+                case 7:
+                    {
+                        option = step.options.find(function (option) { return option.value === value; });
+                        if (!(value === null || value === void 0 ? void 0 : value.value))
+                            return [2 /*return*/, option];
+                        return [2 /*return*/, value];
                     }
-                    for (const idDep of dependencies) {
-                        const mappedIdDep = base + step.id + '-' + idElement + '-' + idDep;
-                        if (!values.sections[step.idSection][idDep] && !values.global[mappedIdDep] && element[idDep]) {
-                            values.global[mappedIdDep] = element[idDep];
-                            mappedElement.ids[idDep] = mappedIdDep;
+                    _p.label = 8;
+                case 8:
+                    {
+                        stepClassifier = (_f = form === null || form === void 0 ? void 0 : form.classifiers) === null || _f === void 0 ? void 0 : _f[(_g = step.idClassifier) !== null && _g !== void 0 ? _g : ''];
+                        if (stepClassifier && !value.value) {
+                            classifier = (_h = form.classifiers) === null || _h === void 0 ? void 0 : _h[value];
+                            return [2 /*return*/, { value: value, label: classifier === null || classifier === void 0 ? void 0 : classifier.name }];
                         }
+                        return [3 /*break*/, 14];
                     }
-                }
-                for (const key of Object.keys(element)) {
-                    if (step.steps[key] || key === 'id')
-                        continue;
-                    mappedElement.originalValues[key] = element[key];
-                }
-                mappedElements.push(mappedElement);
-            }
-            return { elements: mappedElements, page: 0 };
-        }
-        case FormStepTypes.TEXTAREA: {
-            if (step.hasTextEditor) {
-                if (typeof value === 'string') {
-                    return stringToDraft(value);
-                }
-                return getRawText(value?.draft, value?.text);
-            }
-            const defaultValue = value.value ?? value;
-            if (typeof defaultValue === 'string') {
-                return defaultValue;
-            }
-            else {
-                return defaultValue?.text ?? '';
-            }
-        }
-        case FormStepTypes.SELECTOR: {
-            const option = step.options.find((option) => option.value === value);
-            if (!value?.value)
-                return option;
-            return value;
-        }
-        case FormStepTypes.CLASSIFIER_SELECTOR: {
-            const stepClassifier = form?.classifiers?.[step.idClassifier ?? ''];
-            if (stepClassifier && !value.value) {
-                const classifier = form.classifiers?.[value];
-                return { value, label: classifier?.name };
-            }
-            break;
-        }
-        case FormStepTypes.ENTITYVALUEPICKER: {
-            if (!value._id) {
-                const params = new URLSearchParams(value);
-                const url = `${orgInfo.idOrganization}/entities/${step.idEntity}?${params.toString()}`;
-                const entityValues = (await widgetInstance.get(url)).data;
-                if (entityValues.length === 1) {
-                    const entityValue = entityValues[0];
-                    if (step.options[entityValue._id]?.type === EntityValueOptionTypes.HIDE)
-                        return undefined;
-                    return entityValues[0];
-                }
-                return null;
-            }
-            return value;
-        }
-        case FormStepTypes.TEXTINPUT: {
-            if (step.clientInfoType === 'cel' || step.validation?.type === 'PHONE') {
-                if (!isValidPhoneNumber(value)) {
-                    const country = getCountry({
-                        field: 'iso2',
-                        value: orgInfo.countryCode?.toLowerCase() ?? 'co',
-                    });
-                    if (country && isValidPhoneNumber(country.dialCode + value)) {
-                        return country.dialCode + value;
+                    _p.label = 9;
+                case 9:
+                    if (!!value._id) return [3 /*break*/, 11];
+                    params = typeof value !== 'string'
+                        ? new URLSearchParams(value)
+                        : new URLSearchParams();
+                    url = "".concat(orgInfo.idOrganization, "/entities/").concat(step.idEntity, "?").concat(params.toString());
+                    return [4 /*yield*/, widgetInstance.get(url)];
+                case 10:
+                    entityValues = (_p.sent()).data;
+                    if (entityValues.length === 1) {
+                        entityValue = entityValues[0];
+                        if (((_j = step.options[entityValue._id]) === null || _j === void 0 ? void 0 : _j.type) ===
+                            EntityValueOptionTypes.HIDE)
+                            return [2 /*return*/, undefined];
+                        return [2 /*return*/, entityValues[0]];
                     }
-                }
-            }
-            return value;
-        }
-        default:
-            if (step.type.startsWith('CBR_') && value?.id && typeof value.id === 'number') {
-                return { ...value, id: value.id.toString() };
+                    if (typeof value === 'string') {
+                        if (((_k = step.options[value]) === null || _k === void 0 ? void 0 : _k.type) ===
+                            EntityValueOptionTypes.HIDE)
+                            return [2 /*return*/, undefined];
+                        return [2 /*return*/, entityValues.find(function (ev) { return ev._id === value; })];
+                    }
+                    return [2 /*return*/, null];
+                case 11: return [2 /*return*/, value];
+                case 12:
+                    {
+                        if (step.clientInfoType === 'cel' ||
+                            ((_l = step.validation) === null || _l === void 0 ? void 0 : _l.type) === 'PHONE') {
+                            if (!isValidPhoneNumber(value)) {
+                                country = getCountry({
+                                    field: 'iso2',
+                                    value: (_o = (_m = orgInfo.countryCode) === null || _m === void 0 ? void 0 : _m.toLowerCase()) !== null && _o !== void 0 ? _o : 'co',
+                                });
+                                if (country &&
+                                    isValidPhoneNumber(country.dialCode + value)) {
+                                    return [2 /*return*/, country.dialCode + value];
+                                }
+                            }
+                        }
+                        return [2 /*return*/, value];
+                    }
+                    _p.label = 13;
+                case 13:
+                    if (step.type.startsWith('CBR_') &&
+                        (value === null || value === void 0 ? void 0 : value.id) &&
+                        typeof value.id === 'number') {
+                        return [2 /*return*/, __assign(__assign({}, value), { id: value.id.toString() })];
+                    }
+                    return [2 /*return*/, value];
+                case 14: return [2 /*return*/];
             }
-            return value;
-    }
+        });
+    });
 };
 function calcNestedConditionSteps(condition) {
-    const steps = [];
+    var steps = [];
     if (!condition)
         return steps;
     switch (condition.type) {
         case ConditionTypes.EXPRESSION:
-            return condition.conditions.map((condition) => calcNestedConditionSteps(condition)).flat();
+            return condition.conditions
+                .map(function (condition) { return calcNestedConditionSteps(condition); })
+                .flat();
         case ConditionTypes.FORM_STEP:
             return [condition.idStep];
         default:
@@ -211,23 +370,23 @@ function calcNestedConditionSteps(condition) {
     }
     return steps;
 }
-export const calcInitialSections = (form) => {
-    const previousSections = [];
-    const nextSections = calcNextSections(form.firstSection, form);
-    let idCurrentSection = null;
+export var calcInitialSections = function (form) {
+    var previousSections = [];
+    var nextSections = calcNextSections(form.firstSection, form);
+    var idCurrentSection = null;
     if (form.type === FormTypes.STEPPER) {
-        const firstSection = nextSections.shift();
+        var firstSection = nextSections.shift();
         if (firstSection)
             idCurrentSection = firstSection;
     }
-    return { previousSections, idCurrentSection, nextSections };
+    return { previousSections: previousSections, idCurrentSection: idCurrentSection, nextSections: nextSections };
 };
-const calcNextSections = (idSection, form) => {
-    const section = form.sections[idSection];
+var calcNextSections = function (idSection, form) {
+    var section = form.sections[idSection];
     if (!section)
         return [];
-    const sections = [idSection];
+    var sections = [idSection];
     if (section.nextSection)
-        sections.push(...calcNextSections(section.nextSection, form));
+        sections.push.apply(sections, calcNextSections(section.nextSection, form));
     return sections;
 };

package/dist/App/AppHooks.d.ts

@@ -1,10 +1,10 @@
 import { Form, Organization } from '../@Types';
 import { AppProps } from './App';
 import { Branding } from '../@Types/Branding';
-export declare const useSetupApp: (isEmbedded: boolean, props: Omit<AppProps, "isWidget">) => {
+export declare const useSetupApp: (isEmbedded: boolean, { preview, internal, postview, partial, editable, handleConfirmed, customSteps, valuesData, apiKey, formData, classifiers, idCurrentAgent, ...others }: Omit<AppProps, 'isWidget'>) => {
     form: Form | undefined | null;
     organization: Organization | undefined | null;
     branding: Branding | undefined;
     reload: () => void;
 };
-export declare const useLogRocket: (organization: Organization | null | undefined, form: Form | null | undefined, { apiKey, internal, postview, preview }: Pick<AppProps, "apiKey" | "internal" | "postview" | "preview">) => void;
+export declare const useLogRocket: (organization: Organization | null | undefined, form: Form | null | undefined, { apiKey, internal, postview, preview, }: Pick<AppProps, 'apiKey' | 'internal' | 'postview' | 'preview'>) => void;