@arquimedes.co/eureka-forms 3.0.35 → 3.0.37

package/dist/App/AppFunctions.js

@@ -85,13 +85,13 @@ export var calcValuesStore = function (orgInfo, form, originalValues, postview,
                                     case 0:
                                         step = form.steps[idValue];
                                         if (!step) return [3 /*break*/, 2];
+                                        if (!values.sections[step.idSection])
+                                            values.sections[step.idSection] = {};
                                         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 {

package/dist/Services/ApiSelectorService.d.ts

@@ -6,13 +6,7 @@ export declare const ApiSelectorApi: import("@reduxjs/toolkit/query").Api<import
     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/)
-     */
+    params?: any;
     headers?: Record<string, any> | undefined;
 }, unknown, unknown, {}, {}>, {
     fetchApiSelectorOptions: import("@reduxjs/toolkit/query").QueryDefinition<{
@@ -23,13 +17,7 @@ export declare const ApiSelectorApi: import("@reduxjs/toolkit/query").Api<import
         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/)
-         */
+        params?: any;
         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>;
@@ -41,13 +29,7 @@ export declare const useFetchApiSelectorOptionsQuery: import("@reduxjs/toolkit/d
     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/)
-     */
+    params?: any;
     headers?: Record<string, any> | undefined;
 }, unknown, unknown, {}, {}>, never, any[], "api">>;
 /**

package/dist/Services/ApiSelectorService.js

@@ -38,14 +38,15 @@ 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
+ * Queue manager to throttle requests per URL ensuring minimum time between requests
+ * Ensures at least 0.5 second between request starts
  */
 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
+        this.queues = new Map();
+        this.processing = new Map();
+        this.lastRequestTime = new Map();
+        this.MIN_TIME_BETWEEN_REQUESTS_MS = 500; // Minimum 0.5 seconds between requests
     }
     /**
      * Gets the normalized URL key (base + path without query params)
@@ -89,7 +90,7 @@ var RequestThrottleManager = /** @class */ (function () {
         }
     };
     /**
-     * Executes a request with throttling based on time window
+     * Executes a request with throttling using a simple queue
      */
     RequestThrottleManager.prototype.executeRequest = function (url, requestFn) {
         return __awaiter(this, void 0, void 0, function () {
@@ -98,80 +99,70 @@ var RequestThrottleManager = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         urlKey = this.getUrlKey(url);
-                        // Wait until we can make the request
-                        return [4 /*yield*/, this.waitForSlot(urlKey)];
+                        // Wait for our turn in the queue
+                        return [4 /*yield*/, this.waitInQueue(urlKey)];
                     case 1:
-                        // Wait until we can make the request
+                        // Wait for our turn in the queue
                         _a.sent();
-                        // Record the request timestamp
-                        this.recordRequest(urlKey);
+                        // Record when we're starting the request
+                        this.lastRequestTime.set(urlKey, Date.now());
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, , 4, 5]);
                         return [4 /*yield*/, requestFn()];
-                    case 2: 
-                    // Execute the request (no need for try-finally since we already recorded it)
+                    case 3: 
+                    // Execute the request
                     return [2 /*return*/, _a.sent()];
+                    case 4:
+                        // Process next request in queue, waiting if necessary
+                        this.scheduleNextRequest(urlKey);
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
                 }
             });
         });
     };
     /**
-     * Cleans up old timestamps outside the time window
+     * Adds request to queue and waits for its turn
      */
-    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);
-        }
+    RequestThrottleManager.prototype.waitInQueue = function (urlKey) {
+        var _this = this;
+        return new Promise(function (resolve) {
+            var queue = _this.queues.get(urlKey) || [];
+            queue.push({ resolve: resolve, timestamp: Date.now() });
+            _this.queues.set(urlKey, queue);
+            // If not already processing this queue, start processing
+            if (!_this.processing.get(urlKey)) {
+                _this.processQueue(urlKey);
+            }
+        });
     };
     /**
-     * Records a new request timestamp
+     * Processes the next request in the queue
      */
-    RequestThrottleManager.prototype.recordRequest = function (urlKey) {
-        var timestamps = this.requestTimestamps.get(urlKey) || [];
-        timestamps.push(Date.now());
-        this.requestTimestamps.set(urlKey, timestamps);
+    RequestThrottleManager.prototype.processQueue = function (urlKey) {
+        var queue = this.queues.get(urlKey) || [];
+        if (queue.length === 0) {
+            this.processing.set(urlKey, false);
+            return;
+        }
+        this.processing.set(urlKey, true);
+        var resolve = queue.shift().resolve;
+        this.queues.set(urlKey, queue);
+        // Resolve immediately to allow request to proceed
+        resolve();
     };
     /**
-     * Waits until a slot is available in the time window
+     * Schedules the next request in queue, waiting if necessary to maintain minimum time between requests
      */
-    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()];
-                }
-            });
-        });
+    RequestThrottleManager.prototype.scheduleNextRequest = function (urlKey) {
+        var _this = this;
+        var lastTime = this.lastRequestTime.get(urlKey) || 0;
+        var timeSinceLastRequest = Date.now() - lastTime;
+        var waitTime = Math.max(0, this.MIN_TIME_BETWEEN_REQUESTS_MS - timeSinceLastRequest);
+        setTimeout(function () {
+            _this.processQueue(urlKey);
+        }, waitTime);
     };
     return RequestThrottleManager;
 }());

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@arquimedes.co/eureka-forms",
     "repository": "git://github.com/Arquimede5/Eureka-Forms.git",
-    "version": "3.0.35",
+    "version": "3.0.37",
     "scripts": {
         "start": "react-scripts start",
         "build": "react-scripts build",