@arquimedes.co/eureka-forms 3.0.47-test → 3.0.48-test

package/dist/Services/ApiSelectorService.d.ts

@@ -0,0 +1,366 @@
+/**
+ * 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?: 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>, {
+    fetchApiSelectorOptions: import("@reduxjs/toolkit/query").QueryDefinition<{
+        url: string;
+        idOrganization?: string;
+    }, 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, any[], "api", unknown>;
+}, "api", never, typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
+export declare const useFetchApiSelectorOptionsQuery: <R extends Record<string, any> = import("@reduxjs/toolkit/query").TSHelpersId<(Omit<{
+    status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+    originalArgs?: undefined | undefined;
+    data?: undefined | undefined;
+    error?: undefined | undefined;
+    requestId?: undefined | undefined;
+    endpointName?: string | undefined;
+    startedTimeStamp?: undefined | undefined;
+    fulfilledTimeStamp?: undefined | undefined;
+} & {
+    currentData?: any[] | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, "isUninitialized"> & {
+    isUninitialized: true;
+}) | (Omit<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+    url: string;
+    idOrganization?: string;
+}, 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, any[], "api", unknown>> & {
+    currentData?: any[] | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, "data" | "isLoading" | "isFetching"> & {
+    isLoading: true;
+    isFetching: boolean;
+    data: undefined;
+}) | (Omit<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+    url: string;
+    idOrganization?: string;
+}, 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, any[], "api", unknown>> & {
+    currentData?: any[] | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, "data" | "error" | "fulfilledTimeStamp" | "isFetching" | "isSuccess"> & {
+    isSuccess: true;
+    isFetching: true;
+    error: undefined;
+} & {
+    data: any[];
+} & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+    url: string;
+    idOrganization?: string;
+}, 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, any[], "api", unknown>> & {
+    currentData?: any[] | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, "fulfilledTimeStamp">>) | (Omit<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+    url: string;
+    idOrganization?: string;
+}, 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, any[], "api", unknown>> & {
+    currentData?: any[] | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, "data" | "error" | "fulfilledTimeStamp" | "currentData" | "isFetching" | "isSuccess"> & {
+    isSuccess: true;
+    isFetching: false;
+    error: undefined;
+} & {
+    data: any[];
+    currentData: any[];
+} & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+    url: string;
+    idOrganization?: string;
+}, 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, any[], "api", unknown>> & {
+    currentData?: any[] | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, "fulfilledTimeStamp">>) | (Omit<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+    url: string;
+    idOrganization?: string;
+}, 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, any[], "api", unknown>> & {
+    currentData?: any[] | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, "error" | "isError"> & {
+    isError: true;
+} & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+    url: string;
+    idOrganization?: string;
+}, 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, any[], "api", unknown>> & {
+    currentData?: any[] | undefined;
+    isUninitialized: false;
+    isLoading: false;
+    isFetching: false;
+    isSuccess: false;
+    isError: false;
+}, "error">>)> & {
+    status: import("@reduxjs/toolkit/query").QueryStatus;
+}>(arg: typeof import("@reduxjs/toolkit/query").skipToken | {
+    url: string;
+    idOrganization?: string;
+}, options?: (import("@reduxjs/toolkit/query").SubscriptionOptions & {
+    skip?: boolean;
+    refetchOnMountOrArgChange?: boolean | number;
+} & {
+    skip?: boolean;
+    selectFromResult?: ((state: import("@reduxjs/toolkit/query").TSHelpersId<(Omit<{
+        status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+        originalArgs?: undefined | undefined;
+        data?: undefined | undefined;
+        error?: undefined | undefined;
+        requestId?: undefined | undefined;
+        endpointName?: string | undefined;
+        startedTimeStamp?: undefined | undefined;
+        fulfilledTimeStamp?: undefined | undefined;
+    } & {
+        currentData?: any[] | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, "isUninitialized"> & {
+        isUninitialized: true;
+    }) | (Omit<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+        url: string;
+        idOrganization?: string;
+    }, 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, any[], "api", unknown>> & {
+        currentData?: any[] | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, "data" | "isLoading" | "isFetching"> & {
+        isLoading: true;
+        isFetching: boolean;
+        data: undefined;
+    }) | (Omit<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+        url: string;
+        idOrganization?: string;
+    }, 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, any[], "api", unknown>> & {
+        currentData?: any[] | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, "data" | "error" | "fulfilledTimeStamp" | "isFetching" | "isSuccess"> & {
+        isSuccess: true;
+        isFetching: true;
+        error: undefined;
+    } & {
+        data: any[];
+    } & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+        url: string;
+        idOrganization?: string;
+    }, 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, any[], "api", unknown>> & {
+        currentData?: any[] | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, "fulfilledTimeStamp">>) | (Omit<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+        url: string;
+        idOrganization?: string;
+    }, 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, any[], "api", unknown>> & {
+        currentData?: any[] | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, "data" | "error" | "fulfilledTimeStamp" | "currentData" | "isFetching" | "isSuccess"> & {
+        isSuccess: true;
+        isFetching: false;
+        error: undefined;
+    } & {
+        data: any[];
+        currentData: any[];
+    } & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+        url: string;
+        idOrganization?: string;
+    }, 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, any[], "api", unknown>> & {
+        currentData?: any[] | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, "fulfilledTimeStamp">>) | (Omit<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+        url: string;
+        idOrganization?: string;
+    }, 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, any[], "api", unknown>> & {
+        currentData?: any[] | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, "error" | "isError"> & {
+        isError: true;
+    } & Required<Pick<import("@reduxjs/toolkit/query").QuerySubState<import("@reduxjs/toolkit/query").QueryDefinition<{
+        url: string;
+        idOrganization?: string;
+    }, 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, any[], "api", unknown>> & {
+        currentData?: any[] | undefined;
+        isUninitialized: false;
+        isLoading: false;
+        isFetching: false;
+        isSuccess: false;
+        isError: false;
+    }, "error">>)> & {
+        status: import("@reduxjs/toolkit/query").QueryStatus;
+    }) => R) | undefined;
+}) | undefined) => [R][R extends any ? 0 : never] & {
+    refetch: () => import("@reduxjs/toolkit/query").QueryActionCreatorResult<import("@reduxjs/toolkit/query").QueryDefinition<{
+        url: string;
+        idOrganization?: string;
+    }, 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, any[], "api", unknown>>;
+};
+/**
+ * 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,173 @@
+import { RootApi } from '../Utils/_api';
+import widgetInstance from '../Utils/AxiosWidget';
+import axiosInstance from '../Utils/AxiosAPI';
+/**
+ * Queue manager to throttle requests per URL ensuring minimum time between requests
+ * Ensures at least 0.5 second between request starts
+ */
+class RequestThrottleManager {
+    constructor() {
+        Object.defineProperty(this, "queues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "processing", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "lastRequestTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "MIN_TIME_BETWEEN_REQUESTS_MS", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 500
+        }); // Minimum 0.5 seconds between requests
+    }
+    /**
+     * Gets the normalized URL key (base + path without query params)
+     * For URLs containing the forms 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/)
+     */
+    getUrlKey(url) {
+        try {
+            const urlObj = new URL(url, window.location.origin);
+            const domain = import.meta.env.VITE_REACT_APP_DOMAIN ?? 'capta.co';
+            // Check if URL contains the domain
+            if (url.includes(domain)) {
+                // Split path into segments, filter out empty strings
+                const pathSegments = urlObj.pathname.split('/').filter((s) => s.length > 0);
+                let normalizedPath;
+                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 `${urlObj.origin}${normalizedPath}`;
+            }
+            // For non-domain URLs, use full pathname
+            return `${urlObj.origin}${urlObj.pathname}`;
+        }
+        catch {
+            // If URL parsing fails, use the URL up to the query string
+            return url.split('?')[0];
+        }
+    }
+    /**
+     * Executes a request with throttling using a simple queue
+     */
+    async executeRequest(url, requestFn) {
+        const urlKey = this.getUrlKey(url);
+        // Wait for our turn in the queue
+        await this.waitInQueue(urlKey);
+        // Record when we're starting the request
+        this.lastRequestTime.set(urlKey, Date.now());
+        try {
+            // Execute the request
+            return await requestFn();
+        }
+        finally {
+            // Process next request in queue, waiting if necessary
+            this.scheduleNextRequest(urlKey);
+        }
+    }
+    /**
+     * Adds request to queue and waits for its turn
+     */
+    waitInQueue(urlKey) {
+        return new Promise((resolve) => {
+            const queue = this.queues.get(urlKey) ?? [];
+            queue.push({ 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);
+            }
+        });
+    }
+    /**
+     * Processes the next request in the queue
+     */
+    processQueue(urlKey) {
+        const queue = this.queues.get(urlKey) ?? [];
+        if (queue.length === 0) {
+            this.processing.set(urlKey, false);
+            return;
+        }
+        this.processing.set(urlKey, true);
+        const { resolve } = queue.shift();
+        this.queues.set(urlKey, queue);
+        // Resolve immediately to allow request to proceed
+        resolve();
+    }
+    /**
+     * Schedules the next request in queue, waiting if necessary to maintain minimum time between requests
+     */
+    scheduleNextRequest(urlKey) {
+        const lastTime = this.lastRequestTime.get(urlKey) ?? 0;
+        const timeSinceLastRequest = Date.now() - lastTime;
+        const waitTime = Math.max(0, this.MIN_TIME_BETWEEN_REQUESTS_MS - timeSinceLastRequest);
+        setTimeout(() => {
+            this.processQueue(urlKey);
+        }, waitTime);
+    }
+}
+// Global instance of the throttle manager
+const throttleManager = new RequestThrottleManager();
+/**
+ * RTK Query API service for ApiSelector endpoints with request throttling
+ */
+export const ApiSelectorApi = RootApi.injectEndpoints({
+    endpoints: (builder) => ({
+        fetchApiSelectorOptions: builder.query({
+            queryFn: async ({ url, idOrganization }) => {
+                try {
+                    // Use throttle manager to limit concurrent requests per URL
+                    const data = await throttleManager.executeRequest(url, async () => {
+                        const response = await (idOrganization ? widgetInstance.get(url) : axiosInstance.get(url));
+                        return response.data;
+                    });
+                    return { data };
+                }
+                catch (error) {
+                    return {
+                        error: {
+                            status: error.response?.status ?? 500,
+                            data: error.response?.data ?? error.message,
+                        },
+                    };
+                }
+            },
+            // Keep data cached for 60 seconds
+            keepUnusedDataFor: 60,
+        }),
+    }),
+});
+export const { useFetchApiSelectorOptionsQuery } = ApiSelectorApi;
+/**
+ * Standalone throttled fetch function for imperative API calls
+ * This allows using the throttle manager without React hooks
+ */
+export async function fetchApiSelectorOptionsThrottled(url, idOrganization) {
+    return throttleManager.executeRequest(url, async () => {
+        const response = await (idOrganization ? widgetInstance.get(url) : axiosInstance.get(url));
+        return response.data;
+    });
+}

package/dist/Services/ApiSelectorService.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Services/ApiSelectorService.test.js

@@ -0,0 +1,87 @@
+/* eslint-disable @typescript-eslint/unbound-method, @typescript-eslint/require-await, @typescript-eslint/explicit-function-return-type -- test file: vi.mocked()/expect() reference mocked axios methods as values, and the mock factory uses terse async/return types */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { fetchApiSelectorOptionsThrottled } from './ApiSelectorService';
+import widgetInstance from '../Utils/AxiosWidget';
+import axiosInstance from '../Utils/AxiosAPI';
+// Mock the axios instances. AxiosAPI also exports axiosBaseQuery, consumed by
+// _api.ts at import time to build RootApi — keep it callable or the import chain throws.
+vi.mock('../Utils/AxiosWidget', () => ({
+    default: { get: vi.fn() },
+}));
+vi.mock('../Utils/AxiosAPI', () => ({
+    default: { get: vi.fn() },
+    axiosBaseQuery: () => async () => ({ data: undefined }),
+}));
+describe('ApiSelectorService - Request Throttling', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.useFakeTimers();
+    });
+    afterEach(async () => {
+        // Flush the throttle's pending scheduleNextRequest timers so the shared
+        // module singleton's per-URL "processing" flag resets between tests.
+        await vi.runOnlyPendingTimersAsync();
+        vi.useRealTimers();
+    });
+    it('should throttle requests to at least 500ms apart per URL', async () => {
+        const mockUrl = 'https://api.example.com/data';
+        const mockData = [{ id: 1, name: 'Test' }];
+        const requestTimes = [];
+        // Mock axios to record request times
+        vi.mocked(axiosInstance.get).mockImplementation(() => {
+            requestTimes.push(Date.now());
+            return Promise.resolve({ data: mockData });
+        });
+        // Fire 3 requests
+        const promise1 = fetchApiSelectorOptionsThrottled(mockUrl);
+        const promise2 = fetchApiSelectorOptionsThrottled(mockUrl);
+        const promise3 = fetchApiSelectorOptionsThrottled(mockUrl);
+        // Advance time to allow all requests to complete
+        await vi.advanceTimersByTimeAsync(1500);
+        await Promise.all([promise1, promise2, promise3]);
+        // Verify 3 requests were made
+        expect(axiosInstance.get).toHaveBeenCalledTimes(3);
+        // Verify requests were spaced at least 500ms apart
+        for (let i = 1; i < requestTimes.length; i++) {
+            const timeDiff = requestTimes[i] - requestTimes[i - 1];
+            expect(timeDiff).toBeGreaterThanOrEqual(500);
+        }
+    });
+    it('should allow different URLs to execute without interfering', async () => {
+        const mockUrl1 = 'https://api.example.com/data1';
+        const mockUrl2 = 'https://api.example.com/data2';
+        const mockData = [{ id: 1, name: 'Test' }];
+        vi.mocked(axiosInstance.get).mockResolvedValue({ data: mockData });
+        // Fire 2 requests for each URL
+        const promise1 = fetchApiSelectorOptionsThrottled(mockUrl1);
+        const promise2 = fetchApiSelectorOptionsThrottled(mockUrl2);
+        // Both should start immediately (different URLs)
+        await vi.advanceTimersByTimeAsync(0);
+        await Promise.all([promise1, promise2]);
+        // Both URLs should have made their requests
+        expect(axiosInstance.get).toHaveBeenCalledTimes(2);
+    });
+    it('should use widgetInstance when idOrganization is provided', async () => {
+        const mockUrl = 'https://api.example.com/data';
+        const mockData = [{ id: 1, name: 'Test' }];
+        const idOrganization = 'org123';
+        vi.mocked(widgetInstance.get).mockResolvedValue({ data: mockData });
+        await fetchApiSelectorOptionsThrottled(mockUrl, idOrganization);
+        expect(widgetInstance.get).toHaveBeenCalledWith(mockUrl);
+        expect(axiosInstance.get).not.toHaveBeenCalled();
+    });
+    it('should use axiosInstance when idOrganization is not provided', async () => {
+        const mockUrl = 'https://api.example.com/data';
+        const mockData = [{ id: 1, name: 'Test' }];
+        vi.mocked(axiosInstance.get).mockResolvedValue({ data: mockData });
+        await fetchApiSelectorOptionsThrottled(mockUrl);
+        expect(axiosInstance.get).toHaveBeenCalledWith(mockUrl);
+        expect(widgetInstance.get).not.toHaveBeenCalled();
+    });
+    it('should handle errors properly', async () => {
+        const mockUrl = 'https://api.example.com/data';
+        const mockError = new Error('Network error');
+        vi.mocked(axiosInstance.get).mockRejectedValue(mockError);
+        await expect(fetchApiSelectorOptionsThrottled(mockUrl)).rejects.toThrow('Network error');
+    });
+});

package/dist/Services/DraftService.js

@@ -21,7 +21,10 @@ export const DraftApi = RootApi.injectEndpoints({
                     });
                 }
                 else {
-                    response = await axiosInstance.post(`/form/draft/${apiKey}`, dependencies);
+                    response = await axiosInstance.post(`/form/draft/${apiKey}`, {
+                        property,
+                        dependencies,
+                    });
                 }
                 return { data: response.data };
             },

package/dist/Services/IntegrationService.d.ts

@@ -0,0 +1,21 @@
+export declare const IntegrationsApi: 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>, {
+    fetchFilterIntegration: import("@reduxjs/toolkit/query").QueryDefinition<{
+        idForm: string;
+        idIntegration: string;
+        payload: Record<string, any>;
+    }, 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, string[] | undefined, "api", unknown>;
+}, "api", never, typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;