@arquimedes.co/eureka-forms 3.0.34-test → 3.0.35

package/dist/Login/LoginTextField.js

@@ -0,0 +1,134 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import TextField from '@material-ui/core/TextField';
+import { withStyles } from '@material-ui/core/styles';
+import MailOutlineIcon from '@material-ui/icons/MailOutline';
+import InputAdornment from '@material-ui/core/InputAdornment';
+import LockIcon from '@material-ui/icons/Lock';
+var CustomTextField = withStyles({
+    root: {
+        '& input': {
+            padding: '6px 0px',
+            backgroundColor: '#ebebeb',
+            fontWeight: 300,
+            height: 40,
+            borderRadius: 10,
+        },
+        '& label.EF-MuiInputLabel-shrink': {
+            marginTop: '0px',
+            margin: -2,
+        },
+        '& input + fieldset': {
+            borderRadius: 10,
+        },
+        '& .EF-MuiInput-underline:after': {
+            borderBottomColor: '#3d5a7f',
+        },
+        '& .EF-MuiInputBase-root': {
+            backgroundColor: '#ebebeb',
+        },
+        '& .EF-MuiOutlinedInput-root': {
+            borderRadius: 10,
+            backgroundColor: '#ebebeb',
+            '&.Mui-focused fieldset': {
+                borderColor: '#3d5a7f',
+            },
+        },
+        '& label.Mui-focused': {
+            color: '#3d5a7f',
+        },
+        //ESsto es lo nuevo
+        '& input, textarea': {
+            padding: '6px 0px',
+            fontWeight: 300,
+            height: 40,
+            backgroundColor: '#ebebeb',
+            borderRadius: 10,
+        },
+        '& label': {
+            marginTop: '-4px',
+            whiteSpace: 'nowrap',
+            overflow: 'hidden',
+            textOverflow: 'ellipsis',
+            maxWidth: 'calc(100% - 22px)',
+        },
+        '& .EF-MuiOutlinedInput-root:hover .EF-MuiOutlinedInput-notchedOutline': {
+            borderColor: '#3d5a7f',
+        },
+        '& .Mui-error': {},
+        '& .EF-MuiOutlinedInput-adornedEnd': {
+            paddingRight: '7px',
+        },
+        '& .EF-MuiFormHelperText-root': {
+            color: '#0a0101ff',
+            position: 'relative',
+            marginRight: 14,
+        },
+        '& .EF-MuiFormHelperText-root.Mui-error': {
+            color: '#cc2936',
+        },
+        '& .EF-MuiOutlinedInput-multiline': {
+            padding: 0,
+            backgroundColor: '#ebebeb',
+        },
+    },
+})(TextField);
+var LoginTextField = /** @class */ (function (_super) {
+    __extends(LoginTextField, _super);
+    function LoginTextField() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    LoginTextField.prototype.render = function () {
+        var _a = this.props, handleEnter = _a.handleEnter, email = _a.email, onChange = _a.onChange, handleChange = _a.handleChange, others = __rest(_a, ["handleEnter", "email", "onChange", "handleChange"]);
+        return (_jsx(CustomTextField, __assign({}, others, { variant: "outlined", size: "small", fullWidth: true, type: email ? 'email' : 'password', onChange: function (event) {
+                handleChange === null || handleChange === void 0 ? void 0 : handleChange();
+                onChange === null || onChange === void 0 ? void 0 : onChange(event);
+            }, InputProps: {
+                onKeyPress: function (event) {
+                    if (handleEnter && event.key === 'Enter') {
+                        handleEnter();
+                    }
+                },
+                startAdornment: (_jsx(InputAdornment, __assign({ position: "start" }, { children: email ? _jsx(MailOutlineIcon, {}) : _jsx(LockIcon, {}) }))),
+            } })));
+    };
+    return LoginTextField;
+}(React.Component));
+export default LoginTextField;

package/dist/Services/ApiSelectorService.d.ts

@@ -0,0 +1,57 @@
+/**
+ * RTK Query API service for ApiSelector endpoints with request throttling
+ */
+export declare const ApiSelectorApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<{
+    url: string;
+    timeout?: number | undefined;
+    method?: string | undefined;
+    body?: any;
+    params?: any; /**
+     * Gets the normalized URL key (base + path without query params)
+     * For URLs containing REACT_APP_DOMAIN, groups by path segments:
+     * - 3+ segments: use all but last (e.g., /sinco/bitakora/ENDPOINT -> /sinco/bitakora/)
+     * - 2 segments: use first only (e.g., /sinco/bitakora -> /sinco/)
+     * - 1 segment: use first only (e.g., /sinco -> /sinco/)
+     */
+    headers?: Record<string, any> | undefined;
+}, unknown, unknown, {}, {}>, {
+    fetchApiSelectorOptions: import("@reduxjs/toolkit/query").QueryDefinition<{
+        url: string;
+        idOrganization?: string | undefined;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<{
+        url: string;
+        timeout?: number | undefined;
+        method?: string | undefined;
+        body?: any;
+        params?: any; /**
+         * Gets the normalized URL key (base + path without query params)
+         * For URLs containing REACT_APP_DOMAIN, groups by path segments:
+         * - 3+ segments: use all but last (e.g., /sinco/bitakora/ENDPOINT -> /sinco/bitakora/)
+         * - 2 segments: use first only (e.g., /sinco/bitakora -> /sinco/)
+         * - 1 segment: use first only (e.g., /sinco -> /sinco/)
+         */
+        headers?: Record<string, any> | undefined;
+    }, unknown, unknown, {}, {}>, never, any[], "api">;
+}, "api", never, typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;
+export declare const useFetchApiSelectorOptionsQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<{
+    url: string;
+    idOrganization?: string | undefined;
+}, import("@reduxjs/toolkit/query").BaseQueryFn<{
+    url: string;
+    timeout?: number | undefined;
+    method?: string | undefined;
+    body?: any;
+    params?: any; /**
+     * Gets the normalized URL key (base + path without query params)
+     * For URLs containing REACT_APP_DOMAIN, groups by path segments:
+     * - 3+ segments: use all but last (e.g., /sinco/bitakora/ENDPOINT -> /sinco/bitakora/)
+     * - 2 segments: use first only (e.g., /sinco/bitakora -> /sinco/)
+     * - 1 segment: use first only (e.g., /sinco -> /sinco/)
+     */
+    headers?: Record<string, any> | undefined;
+}, unknown, unknown, {}, {}>, never, any[], "api">>;
+/**
+ * Standalone throttled fetch function for imperative API calls
+ * This allows using the throttle manager without React hooks
+ */
+export declare function fetchApiSelectorOptionsThrottled(url: string, idOrganization?: string): Promise<any[]>;

package/dist/Services/ApiSelectorService.js

@@ -0,0 +1,253 @@
+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 };
+    }
+};
+import { RootApi } from '../Utils/_api';
+import widgetInstance from '../Utils/AxiosWidget';
+import axiosInstance from '../Utils/AxiosAPI';
+/**
+ * Queue manager to throttle requests per URL using a time-window approach
+ * Limits total number of requests per time window regardless of response time
+ */
+var RequestThrottleManager = /** @class */ (function () {
+    function RequestThrottleManager() {
+        this.requestTimestamps = new Map();
+        this.MAX_REQUESTS_PER_WINDOW = 1; // Max 1 request per time window
+        this.TIME_WINDOW_MS = 1000; // 1 second time window
+    }
+    /**
+     * Gets the normalized URL key (base + path without query params)
+     * For URLs containing REACT_APP_DOMAIN, groups by path segments:
+     * - 3+ segments: use all but last (e.g., /sinco/bitakora/ENDPOINT -> /sinco/bitakora/)
+     * - 2 segments: use first only (e.g., /sinco/bitakora -> /sinco/)
+     * - 1 segment: use first only (e.g., /sinco -> /sinco/)
+     */
+    RequestThrottleManager.prototype.getUrlKey = function (url) {
+        try {
+            var urlObj = new URL(url, window.location.origin);
+            var domain = process.env.REACT_APP_DOMAIN || 'capta.co';
+            // Check if URL contains the domain
+            if (url.includes(domain)) {
+                // Split path into segments, filter out empty strings
+                var pathSegments = urlObj.pathname
+                    .split('/')
+                    .filter(function (s) { return s.length > 0; });
+                var normalizedPath = void 0;
+                if (pathSegments.length >= 3) {
+                    // 3+ parts: use all but last
+                    normalizedPath =
+                        '/' + pathSegments.slice(0, -1).join('/') + '/';
+                }
+                else if (pathSegments.length >= 1) {
+                    // 1-2 parts: use first part only
+                    normalizedPath = '/' + pathSegments[0] + '/';
+                }
+                else {
+                    // No path segments
+                    normalizedPath = '/';
+                }
+                return "".concat(urlObj.origin).concat(normalizedPath);
+            }
+            // For non-domain URLs, use full pathname
+            return "".concat(urlObj.origin).concat(urlObj.pathname);
+        }
+        catch (_a) {
+            // If URL parsing fails, use the URL up to the query string
+            return url.split('?')[0];
+        }
+    };
+    /**
+     * Executes a request with throttling based on time window
+     */
+    RequestThrottleManager.prototype.executeRequest = function (url, requestFn) {
+        return __awaiter(this, void 0, void 0, function () {
+            var urlKey;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        urlKey = this.getUrlKey(url);
+                        // Wait until we can make the request
+                        return [4 /*yield*/, this.waitForSlot(urlKey)];
+                    case 1:
+                        // Wait until we can make the request
+                        _a.sent();
+                        // Record the request timestamp
+                        this.recordRequest(urlKey);
+                        return [4 /*yield*/, requestFn()];
+                    case 2: 
+                    // Execute the request (no need for try-finally since we already recorded it)
+                    return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Cleans up old timestamps outside the time window
+     */
+    RequestThrottleManager.prototype.cleanupOldTimestamps = function (urlKey) {
+        var timestamps = this.requestTimestamps.get(urlKey) || [];
+        var now = Date.now();
+        var cutoff = now - this.TIME_WINDOW_MS;
+        // Filter out timestamps older than the time window
+        var validTimestamps = timestamps.filter(function (ts) { return ts > cutoff; });
+        if (validTimestamps.length > 0) {
+            this.requestTimestamps.set(urlKey, validTimestamps);
+        }
+        else {
+            this.requestTimestamps.delete(urlKey);
+        }
+    };
+    /**
+     * Records a new request timestamp
+     */
+    RequestThrottleManager.prototype.recordRequest = function (urlKey) {
+        var timestamps = this.requestTimestamps.get(urlKey) || [];
+        timestamps.push(Date.now());
+        this.requestTimestamps.set(urlKey, timestamps);
+    };
+    /**
+     * Waits until a slot is available in the time window
+     */
+    RequestThrottleManager.prototype.waitForSlot = function (urlKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var timestamps, oldestTimestamp, now, timeUntilSlotAvailable;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // Clean up old timestamps first
+                        this.cleanupOldTimestamps(urlKey);
+                        timestamps = this.requestTimestamps.get(urlKey) || [];
+                        if (timestamps.length < this.MAX_REQUESTS_PER_WINDOW) {
+                            // Slot available, can proceed immediately
+                            return [2 /*return*/, Promise.resolve()];
+                        }
+                        oldestTimestamp = timestamps[0];
+                        now = Date.now();
+                        timeUntilSlotAvailable = oldestTimestamp + this.TIME_WINDOW_MS - now;
+                        if (!(timeUntilSlotAvailable > 0)) return [3 /*break*/, 2];
+                        // Wait for the slot to become available
+                        return [4 /*yield*/, new Promise(function (resolve) {
+                                return setTimeout(resolve, timeUntilSlotAvailable + 10);
+                            })];
+                    case 1:
+                        // Wait for the slot to become available
+                        _a.sent(); // +10ms buffer
+                        // Recursively check again (in case multiple requests are queued)
+                        return [2 /*return*/, this.waitForSlot(urlKey)];
+                    case 2: 
+                    // Slot should be available now
+                    return [2 /*return*/, Promise.resolve()];
+                }
+            });
+        });
+    };
+    return RequestThrottleManager;
+}());
+// Global instance of the throttle manager
+var throttleManager = new RequestThrottleManager();
+/**
+ * RTK Query API service for ApiSelector endpoints with request throttling
+ */
+export var ApiSelectorApi = RootApi.injectEndpoints({
+    endpoints: function (builder) { return ({
+        fetchApiSelectorOptions: builder.query({
+            queryFn: function (_a) {
+                var url = _a.url, idOrganization = _a.idOrganization;
+                return __awaiter(void 0, void 0, void 0, function () {
+                    var data, error_1;
+                    var _b, _c;
+                    return __generator(this, function (_d) {
+                        switch (_d.label) {
+                            case 0:
+                                _d.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, throttleManager.executeRequest(url, function () { return __awaiter(void 0, void 0, void 0, function () {
+                                        var response;
+                                        return __generator(this, function (_a) {
+                                            switch (_a.label) {
+                                                case 0: return [4 /*yield*/, (idOrganization
+                                                        ? widgetInstance.get(url)
+                                                        : axiosInstance.get(url))];
+                                                case 1:
+                                                    response = _a.sent();
+                                                    return [2 /*return*/, response.data];
+                                            }
+                                        });
+                                    }); })];
+                            case 1:
+                                data = _d.sent();
+                                return [2 /*return*/, { data: data }];
+                            case 2:
+                                error_1 = _d.sent();
+                                return [2 /*return*/, {
+                                        error: {
+                                            status: ((_b = error_1.response) === null || _b === void 0 ? void 0 : _b.status) || 500,
+                                            data: ((_c = error_1.response) === null || _c === void 0 ? void 0 : _c.data) || error_1.message,
+                                        },
+                                    }];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                });
+            },
+            // Keep data cached for 60 seconds
+            keepUnusedDataFor: 60,
+        }),
+    }); },
+});
+export var useFetchApiSelectorOptionsQuery = ApiSelectorApi.useFetchApiSelectorOptionsQuery;
+/**
+ * Standalone throttled fetch function for imperative API calls
+ * This allows using the throttle manager without React hooks
+ */
+export function fetchApiSelectorOptionsThrottled(url, idOrganization) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _this = this;
+        return __generator(this, function (_a) {
+            return [2 /*return*/, throttleManager.executeRequest(url, function () { return __awaiter(_this, void 0, void 0, function () {
+                    var response;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, (idOrganization
+                                    ? widgetInstance.get(url)
+                                    : axiosInstance.get(url))];
+                            case 1:
+                                response = _a.sent();
+                                return [2 /*return*/, response.data];
+                        }
+                    });
+                }); })];
+        });
+    });
+}

package/dist/Services/DraftService.d.ts

@@ -1,23 +1,23 @@
 import { EurekaDraft } from '../@Types/Draft/Draft';
 export declare const DraftApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<{
     url: string;
-    timeout?: import("axios").AxiosRequestConfig["timeout"];
-    method?: import("axios").AxiosRequestConfig["method"];
-    body?: import("axios").AxiosRequestConfig["data"];
-    params?: import("axios").AxiosRequestConfig["params"];
-    headers?: Record<string, any>;
-}, unknown, unknown>, {
+    timeout?: number | undefined;
+    method?: string | undefined;
+    body?: any;
+    params?: any;
+    headers?: Record<string, any> | undefined;
+}, unknown, unknown, {}, {}>, {
     mapDraft: import("@reduxjs/toolkit/query").QueryDefinition<{
         idForm: string;
         property: string;
         dependencies: Record<string, any>;
-        mapDraftEntities?: (property: string, dependencies: Record<string, any>) => Promise<EurekaDraft>;
+        mapDraftEntities?: ((property: string, dependencies: Record<string, any>) => Promise<EurekaDraft>) | undefined;
     }, import("@reduxjs/toolkit/query").BaseQueryFn<{
         url: string;
-        timeout?: import("axios").AxiosRequestConfig["timeout"];
-        method?: import("axios").AxiosRequestConfig["method"];
-        body?: import("axios").AxiosRequestConfig["data"];
-        params?: import("axios").AxiosRequestConfig["params"];
-        headers?: Record<string, any>;
-    }, unknown, unknown>, never, EurekaDraft | undefined, "api", unknown>;
-}, "api", never, typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
+        timeout?: number | undefined;
+        method?: string | undefined;
+        body?: any;
+        params?: any;
+        headers?: Record<string, any> | undefined;
+    }, unknown, unknown, {}, {}>, never, EurekaDraft | undefined, "api">;
+}, "api", never, typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;

package/dist/Services/DraftService.js

@@ -1,30 +1,80 @@
+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 };
+    }
+};
 import { RootApi } from '../Utils/_api';
 import axiosInstance from '../Utils/AxiosAPI';
 import widgetInstance from '../Utils/AxiosWidget';
-export const DraftApi = RootApi.injectEndpoints({
-    endpoints: (build) => ({
+export var DraftApi = RootApi.injectEndpoints({
+    endpoints: function (build) { return ({
         mapDraft: build.query({
-            queryFn: async ({ idForm, dependencies, property, mapDraftEntities }, { getState }) => {
-                const idOrganization = getState().forms[idForm].global.idOrganization;
-                if (mapDraftEntities)
-                    return {
-                        data: await mapDraftEntities(property, dependencies),
-                    };
-                const apiKey = getState().forms[idForm].global.apiKey;
-                if (!apiKey)
-                    return { data: undefined };
-                let response;
-                if (idOrganization) {
-                    response = await widgetInstance.post(`/form/draft/${apiKey}?idOrganization=${idOrganization}`, {
-                        property,
-                        dependencies,
+            queryFn: function (_a, _b) {
+                var idForm = _a.idForm, dependencies = _a.dependencies, property = _a.property, mapDraftEntities = _a.mapDraftEntities;
+                var getState = _b.getState;
+                return __awaiter(void 0, void 0, void 0, function () {
+                    var idOrganization, apiKey, response;
+                    var _c;
+                    return __generator(this, function (_d) {
+                        switch (_d.label) {
+                            case 0:
+                                idOrganization = getState().forms[idForm]
+                                    .global.idOrganization;
+                                if (!mapDraftEntities) return [3 /*break*/, 2];
+                                _c = {};
+                                return [4 /*yield*/, mapDraftEntities(property, dependencies)];
+                            case 1: return [2 /*return*/, (_c.data = _d.sent(),
+                                    _c)];
+                            case 2:
+                                apiKey = getState().forms[idForm].global
+                                    .apiKey;
+                                if (!apiKey)
+                                    return [2 /*return*/, { data: undefined }];
+                                if (!idOrganization) return [3 /*break*/, 4];
+                                return [4 /*yield*/, widgetInstance.post("/form/draft/".concat(apiKey, "?idOrganization=").concat(idOrganization), { property: property, dependencies: dependencies })];
+                            case 3:
+                                response = _d.sent();
+                                return [3 /*break*/, 6];
+                            case 4: return [4 /*yield*/, axiosInstance.post("/form/draft/".concat(apiKey), { property: property, dependencies: dependencies })];
+                            case 5:
+                                response = _d.sent();
+                                _d.label = 6;
+                            case 6: return [2 /*return*/, { data: response.data }];
+                        }
                     });
-                }
-                else {
-                    response = await axiosInstance.post(`/form/draft/${apiKey}`, dependencies);
-                }
-                return { data: response.data };
+                });
             },
         }),
-    }),
+    }); },
 });

package/dist/Services/FileService.d.ts

@@ -1,4 +1,4 @@
-export declare function getUploadUrls(files: File[], idOrganization?: string): Promise<(Record<string, any> | string)[]>;
+export declare function getUploadUrls(files: Array<File>, idOrganization?: string): Promise<(Record<string, any> | string)[]>;
 export declare function postFile(file: File, postInfo: Record<string, any>): Promise<{
     fileName: string;
     S3Key: string;