@go-avro/avro-js 0.0.2-beta.1 → 0.0.2-beta.100

package/dist/client/QueryClient.js

@@ -1,6 +1,11 @@
+import io from 'socket.io-client';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { LoginResponse } from '../types/api';
 import { StandardError } from '../types/error';
 export class AvroQueryClient {
     constructor(config) {
+        this._isAuthenticated = false;
+        this.companyId = null;
         this.config = {
             baseUrl: config.baseUrl,
             authManager: config.authManager,
@@ -8,112 +13,392 @@ export class AvroQueryClient {
             retryStrategy: config.retryStrategy ?? 'fixed',
             timeout: config.timeout ?? 0,
         };
-    }
-    getDelay(strategy, attempt) {
-        if (typeof strategy === 'function') {
-            return strategy(attempt);
-        }
-        else if (strategy === 'fixed') {
-            return 1000;
+        config.authManager.isAuthenticated().then(isAuth => {
+            this._isAuthenticated = isAuth;
+        });
+        config.authManager.getCompanyId().then(companyId => {
+            this.companyId = companyId;
+        });
+        this.socket = io(config.baseUrl, { autoConnect: false, transports: ["websocket"], });
+        if (!this.socket.connected) {
+            this.config.authManager.accessToken().then(token => {
+                console.log('Initializing socket connection with token...');
+                this.socket.auth = { token: token };
+                this.socket.connect();
+            });
         }
-        else if (strategy === 'exponential') {
-            return Math.pow(2, attempt) * 100;
+        this.socket.on('connect', () => {
+            this._isAuthenticated = true;
+            console.log(`Socket connected with ID: ${this.socket?.id}`);
+        });
+        this.socket.on('disconnect', (reason) => {
+            console.log(`Socket disconnected: ${reason}`);
+        });
+        this.socket.on('connect_error', (err) => {
+            console.error(`Socket connection error: ${err.message}`);
+        });
+        this.config.authManager.onTokenRefreshed((newAccessToken) => {
+            if (this.socket && newAccessToken) {
+                this._isAuthenticated = true;
+                console.log('Access token refreshed, updating socket auth...');
+                this.socket.auth = { token: newAccessToken };
+                this.socket.disconnect().connect();
+            }
+        });
+        config.authManager.onTokenRefreshFailed(() => {
+            this._isAuthenticated = false;
+            if (this.socket && this.socket.connected) {
+                this.socket.disconnect();
+            }
+        });
+    }
+    emit(eventName, data) {
+        if (!this.socket?.connected) {
+            console.error('Socket is not connected. Cannot emit event.');
+            return;
         }
-        throw new Error(`Invalid retry strategy: ${strategy}`);
+        this.socket.emit(eventName, data);
     }
-    _xhr(method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0) {
-        const checkCancelled = () => {
-            if (cancelToken?.isCancelled()) {
-                return new StandardError(0, 'Request cancelled');
-            }
-            return null;
-        };
-        return this.config.authManager.accessToken().then(token => {
-            return new Promise((resolve, reject) => {
-                const cancelErr = checkCancelled();
-                if (cancelErr)
-                    return reject(cancelErr);
-                const xhr = new XMLHttpRequest();
-                const url = this.config.baseUrl + path;
-                xhr.open(method, url, true);
-                if (token) {
-                    xhr.setRequestHeader('Authorization', `Bearer ${token}`);
-                }
-                Object.entries(headers).forEach(([key, value]) => {
-                    xhr.setRequestHeader(key, value);
-                });
-                xhr.onload = () => {
-                    const cancelErr = checkCancelled();
-                    if (cancelErr)
-                        return reject(cancelErr);
-                    if (xhr.status === 401 && this.config.authManager.refreshTokens && retryCount === 0) {
-                        this.config.authManager
-                            .refreshTokens()
-                            .then(() => {
-                            this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
-                        })
-                            .catch(() => {
-                            reject(new StandardError(401, 'Unauthorized (refresh failed)'));
-                        });
-                        return;
-                    }
-                    if (xhr.status >= 200 && xhr.status < 300) {
-                        try {
-                            resolve(JSON.parse(xhr.responseText));
-                        }
-                        catch {
-                            resolve(xhr.responseText);
-                        }
-                    }
-                    else {
-                        if (retryCount < this.config.maxRetries) {
-                            const delay = this.getDelay(this.config.retryStrategy, retryCount);
-                            setTimeout(() => {
-                                this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
-                            }, delay);
-                        }
-                        else {
-                            let msg = xhr.statusText;
-                            try {
-                                const parsed = JSON.parse(xhr.responseText);
-                                msg = parsed.message || msg;
-                            }
-                            catch {
-                                console.warn('Failed to parse error response:', xhr.responseText);
-                            }
-                            reject(new StandardError(xhr.status, msg));
-                        }
-                    }
-                };
-                xhr.onerror = () => {
-                    if (retryCount < this.config.maxRetries) {
-                        const delay = this.getDelay(this.config.retryStrategy, retryCount);
-                        setTimeout(() => {
-                            this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
-                        }, delay);
+    on(eventName, callback) {
+        this.socket?.on(eventName, callback);
+    }
+    off(eventName, callback) {
+        this.socket?.off(eventName, callback);
+    }
+    get(path, cancelToken, headers = {}, progressUpdateCallback) {
+        return this._xhr('GET', path, null, cancelToken, headers, true, this.config.maxRetries, progressUpdateCallback);
+    }
+    post(path, data, cancelToken, headers = {}, progressUpdateCallback) {
+        return this._xhr('POST', path, data, cancelToken, headers, false, this.config.maxRetries, progressUpdateCallback);
+    }
+    put(path, data, cancelToken, headers = {}, progressUpdateCallback) {
+        return this._xhr('PUT', path, data, cancelToken, headers, true, this.config.maxRetries, progressUpdateCallback);
+    }
+    delete(path, cancelToken, headers = {}, progressUpdateCallback) {
+        return this._xhr('DELETE', path, null, cancelToken, headers, false, this.config.maxRetries, progressUpdateCallback);
+    }
+    useLogin() {
+        const queryClient = useQueryClient();
+        return useMutation({
+            mutationFn: async ({ username, password, code, cancelToken }) => {
+                const resp = await this.post('/login', JSON.stringify({ username, password, code }), cancelToken, { 'Content-Type': 'application/json' });
+                if (!resp || !('access_token' in resp)) {
+                    if (resp.msg === "TOTP required") {
+                        return LoginResponse.NEEDS_TOTP;
                     }
-                    else {
-                        reject(new StandardError(0, 'Network Error'));
+                    throw new StandardError(401, 'Invalid login response');
+                }
+                this._isAuthenticated = true;
+                this.socket.auth = { token: resp.access_token };
+                if (!this.socket.connected) {
+                    this.socket.connect();
+                }
+                await this.config.authManager.setTokens({ access_token: resp.access_token, refresh_token: resp.refresh_token });
+                return LoginResponse.SUCCESS;
+            },
+            onSettled: () => {
+                queryClient.invalidateQueries();
+            },
+            onError: (err) => {
+                this.config.authManager.clearCache();
+                throw new StandardError(401, err.message || 'Login failed');
+            }
+        });
+    }
+    useRequestCode() {
+        const queryClient = useQueryClient();
+        return useMutation({
+            mutationFn: async ({ username, email, cancelToken }) => {
+                const resp = await this.post('/code', JSON.stringify({ username, email }), cancelToken, { 'Content-Type': 'application/json' });
+                return resp;
+            },
+            onSettled: () => {
+                queryClient.invalidateQueries();
+            },
+            onError: (err) => {
+                throw new StandardError(err.status, err.message || 'Request code failed');
+            }
+        });
+    }
+    useUpdatePassword() {
+        const queryClient = useQueryClient();
+        return useMutation({
+            mutationFn: async ({ username, email, code, newPassword, cancelToken }) => {
+                await this.post(`/user/${username ?? email}/password`, JSON.stringify({ code, password: newPassword }), cancelToken, { 'Content-Type': 'application/json' });
+            },
+            onSettled: () => {
+                queryClient.invalidateQueries();
+            },
+            onError: (err) => {
+                throw new StandardError(err.status, err.message || 'Update password failed');
+            }
+        });
+    }
+    useGoogleLogin() {
+        const queryClient = useQueryClient();
+        return useMutation({
+            mutationFn: async ({ token, cancelToken }) => {
+                const resp = await this._xhr('POST', `/google/authorize?token=${token}`, {}, cancelToken, { 'Content-Type': 'application/json' });
+                if (!resp || !('access_token' in resp)) {
+                    if (resp.msg === "TOTP required") {
+                        return LoginResponse.NEEDS_TOTP;
                     }
-                };
-                if (this.config.timeout) {
-                    xhr.timeout = this.config.timeout;
-                    xhr.ontimeout = () => reject(new StandardError(0, 'Request timed out'));
+                    throw new StandardError(401, 'Invalid Google login response');
                 }
-                xhr.send(body);
-            });
+                this.socket.auth = { token: resp.access_token };
+                if (!this.socket.connected) {
+                    this.socket.connect();
+                }
+                await this.config.authManager.setTokens({ access_token: resp.access_token, refresh_token: resp.refresh_token });
+                return LoginResponse.SUCCESS;
+            },
+            onSettled: () => {
+                queryClient.invalidateQueries();
+            },
+            onError: (err) => {
+                this.config.authManager.clearCache();
+                throw new StandardError(err.status, err.message || 'Google Login failed');
+            }
+        });
+    }
+    setTokens(tokens) {
+        return this.config.authManager.setTokens(tokens);
+    }
+    setCache(data) {
+        return this.config.authManager.setCache(data);
+    }
+    setCompanyId(companyId) {
+        this.companyId = companyId;
+        this.config.authManager.setCompanyId(companyId);
+    }
+    clearCache() {
+        return this.config.authManager.clearCache();
+    }
+    isAuthenticated() {
+        return this._isAuthenticated;
+    }
+    isAuthenticatedAsync() {
+        return this.config.authManager.isAuthenticated();
+    }
+    useLogout() {
+        const queryClient = useQueryClient();
+        return useMutation({
+            mutationFn: async (cancelToken) => {
+                await this.post('/logout', null, cancelToken);
+                await this.config.authManager.clearCache();
+                if (this.socket && this.socket.connected) {
+                    this.socket.disconnect();
+                }
+            },
+            onSettled: () => {
+                this._isAuthenticated = false;
+                queryClient.invalidateQueries();
+            },
+            onError: (err) => {
+                this.config.authManager.clearCache();
+                console.error('Logout failed:', err);
+                throw new StandardError(500, 'Logout failed');
+            }
         });
     }
-    get(path, cancelToken, headers = {}) {
-        return this._xhr('GET', path, null, cancelToken, headers, true);
+    fetchJobs(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        return this._fetch('POST', `/company/${this.companyId}/jobs`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid jobs response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch jobs:', err);
+            throw new StandardError(500, 'Failed to fetch jobs');
+        });
     }
-    post(path, data, cancelToken, headers = {}) {
-        return this._xhr('POST', path, data, cancelToken, headers, false);
+    fetchChats(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        return this._fetch('POST', `/company/${this.companyId}/chats`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid chats response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch chats:', err);
+            throw new StandardError(500, 'Failed to fetch chats');
+        });
     }
-    put(path, data, cancelToken, headers = {}) {
-        return this._xhr('PUT', path, data, cancelToken, headers, true);
+    fetchMessages(chatId, body = {}, cancelToken, headers = {}) {
+        if (!chatId || chatId.trim() === '') {
+            throw new StandardError(400, 'Chat ID is required');
+        }
+        return this._fetch('POST', `/chat/${chatId}/messages`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid messages response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch messages:', err);
+            throw new StandardError(500, 'Failed to fetch messages');
+        });
+    }
+    async fetchEvents(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        return this._fetch('POST', `/company/${this.companyId}/events`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid events response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch events:', err);
+            throw new StandardError(500, 'Failed to fetch events');
+        });
     }
-    delete(path, cancelToken, headers = {}) {
-        return this._xhr('DELETE', path, null, cancelToken, headers, false);
+    fetchMonths(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        return this._fetch('POST', `/company/${this.companyId}/months`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid months response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch months:', err);
+            throw new StandardError(500, 'Failed to fetch months');
+        });
+    }
+    fetchBills(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        return this._fetch('POST', `/company/${this.companyId}/bills`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid bills response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch bills:', err);
+            throw new StandardError(500, 'Failed to fetch bills');
+        });
+    }
+    fetchRoutes(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        return this._fetch('POST', `/company/${this.companyId}/routes`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid routes response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch routes:', err);
+            throw new StandardError(500, 'Failed to fetch routes');
+        });
+    }
+    fetchTeams(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        return this._fetch('POST', `/company/${this.companyId}/teams`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid teams response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch teams:', err);
+            throw new StandardError(500, 'Failed to fetch teams');
+        });
+    }
+    fetchSessions(body = {}, cancelToken, headers = {}) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        return this._fetch('POST', `/company/${this.companyId}/sessions`, JSON.stringify(body), cancelToken, {
+            ...headers,
+            'Content-Type': 'application/json',
+        })
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid sessions response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch sessions:', err);
+            throw new StandardError(500, 'Failed to fetch sessions');
+        });
+    }
+    sendEmail(emailId, formData, progressUpdateCallback) {
+        try {
+            return this.post(`/email/${emailId}`, formData, undefined, {}, progressUpdateCallback);
+        }
+        catch (error) {
+            throw new StandardError(500, `Failed to send email: ${error}`);
+        }
+    }
+    createBill(data, cancelToken) {
+        if (!this.companyId || this.companyId.trim() === '') {
+            throw new StandardError(400, 'Company ID is required');
+        }
+        const body = {
+            events: data.line_items.filter(item => item.line_item_type === 'EVENT').map(item => item.id),
+            months: data.line_items.filter(item => item.line_item_type === 'SERVICE_MONTH').map(item => item.id),
+            line_items: data.line_items.filter(item => item.line_item_type === 'CUSTOM'),
+            manual_emails: data.custom_emails,
+            users: data.users,
+            due_date: data.due_date,
+        };
+        try {
+            return this._xhr('POST', `/company/${this.companyId}/bill`, JSON.stringify(body), cancelToken, {
+                'Content-Type': 'application/json',
+            });
+        }
+        catch (error) {
+            throw new StandardError(500, `Failed to create bill: ${error}`);
+        }
     }
 }

package/dist/client/core/fetch.d.ts

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

package/dist/client/core/fetch.js

@@ -0,0 +1,62 @@
+import { AvroQueryClient } from '../../client/QueryClient';
+import { StandardError } from '../../types/error';
+AvroQueryClient.prototype._fetch = async function (method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0) {
+    const checkCancelled = () => {
+        try {
+            if (cancelToken?.isCancelled()) {
+                throw new StandardError(0, 'Request cancelled');
+            }
+        }
+        catch (error) {
+            throw new StandardError(0, `Error checking cancellation: ${error.message}`);
+        }
+    };
+    try {
+        checkCancelled();
+        const token = await this.config.authManager.accessToken();
+        checkCancelled();
+        const url = this.config.baseUrl + path;
+        const requestHeaders = {
+            Authorization: `Bearer ${token}`,
+            ...headers,
+        };
+        const options = {
+            method,
+            headers: requestHeaders,
+            body,
+        };
+        const response = await fetch(url, options);
+        if (response.ok) {
+            const text = await response.text();
+            if (!text) {
+                return undefined;
+            }
+            return JSON.parse(text);
+        }
+        if (response.status === 401 && this.config.authManager.refreshTokens && retryCount === 0) {
+            await this.config.authManager.refreshTokens();
+            return this._fetch(method, path, body, cancelToken, headers, isIdempotent, 1);
+        }
+        if (retryCount < this.config.maxRetries) {
+            const delay = this.getDelay(this.config.retryStrategy, retryCount);
+            await this.sleep(delay);
+            return this._fetch(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1);
+        }
+        let errorMessage = response.statusText;
+        try {
+            const parsedError = await response.json();
+            errorMessage = parsedError.message ?? parsedError.msg ?? errorMessage;
+        }
+        catch (e) {
+            console.error('Ignoring:', e);
+        }
+        throw new StandardError(response.status, errorMessage);
+    }
+    catch (error) {
+        if (error instanceof StandardError) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new StandardError(0, `Request failed: ${message}`);
+    }
+};

package/dist/client/core/utils.d.ts

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

package/dist/client/core/utils.js

@@ -0,0 +1,14 @@
+import { AvroQueryClient } from '../../client/QueryClient';
+AvroQueryClient.prototype.getDelay = function (strategy, attempt) {
+    if (typeof strategy === 'function') {
+        return strategy(attempt);
+    }
+    else if (strategy === 'fixed') {
+        return 1000;
+    }
+    else if (strategy === 'exponential') {
+        return Math.pow(2, attempt) * 100;
+    }
+    throw new Error(`Invalid retry strategy: ${strategy}`);
+};
+AvroQueryClient.prototype.sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

package/dist/client/core/xhr.d.ts

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

package/dist/client/core/xhr.js

@@ -0,0 +1,84 @@
+import { AvroQueryClient } from '../../client/QueryClient';
+import { StandardError } from '../../types/error';
+AvroQueryClient.prototype._xhr = async function (method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0, progressUpdateCallback) {
+    const checkCancelled = () => {
+        if (cancelToken?.isCancelled()) {
+            throw new StandardError(0, 'Request cancelled');
+        }
+    };
+    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+        try {
+            checkCancelled();
+            const token = await this.config.authManager.accessToken();
+            checkCancelled();
+            const result = await new Promise((resolve, reject) => {
+                const xhr = new XMLHttpRequest();
+                const url = this.config.baseUrl + path;
+                xhr.open(method, url, true);
+                if (token)
+                    xhr.setRequestHeader('Authorization', `Bearer ${token}`);
+                Object.entries(headers).forEach(([key, value]) => xhr.setRequestHeader(key, value));
+                xhr.onload = () => {
+                    if (xhr.status >= 200 && xhr.status < 300) {
+                        try {
+                            const responseText = xhr.responseText;
+                            if (!responseText) {
+                                return resolve(undefined);
+                            }
+                            resolve(JSON.parse(responseText));
+                        }
+                        catch (e) {
+                            reject(new StandardError(0, `Failed to parse successful response: ${e.message}`));
+                        }
+                    }
+                    else {
+                        let msg = xhr.responseText || xhr.statusText;
+                        try {
+                            const parsed = JSON.parse(xhr.responseText);
+                            msg = parsed.message ?? parsed.msg ?? msg;
+                        }
+                        catch (e) {
+                            console.error('Ignoring:', e);
+                        }
+                        reject(new StandardError(xhr.status, msg));
+                    }
+                };
+                xhr.onerror = () => reject(new StandardError(0, 'Network Error'));
+                if (this.config.timeout) {
+                    xhr.timeout = this.config.timeout;
+                    xhr.ontimeout = () => reject(new StandardError(0, 'Request timed out'));
+                }
+                if (progressUpdateCallback && xhr.upload) {
+                    xhr.upload.onprogress = (event) => {
+                        if (event.lengthComputable) {
+                            progressUpdateCallback(event.loaded, event.total);
+                        }
+                    };
+                }
+                xhr.send(body);
+            });
+            return result;
+        }
+        catch (error) {
+            if (!(error instanceof StandardError)) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new StandardError(0, `An unexpected error occurred: ${message}`);
+            }
+            if (error.status === 401 && this.config.authManager.refreshTokens && attempt === 0) {
+                try {
+                    await this.config.authManager.refreshTokens();
+                    continue;
+                }
+                catch (refreshError) {
+                    throw new StandardError(401, 'Unauthorized (refresh failed)');
+                }
+            }
+            if (attempt >= this.config.maxRetries) {
+                throw error;
+            }
+            const delay = this.getDelay(this.config.retryStrategy, attempt);
+            await this.sleep(delay);
+        }
+    }
+    throw new StandardError(0, 'Request failed after maximum retries.');
+};

package/dist/client/hooks/analytics.d.ts

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