@oxy.so/core 1.0.0

package/dist/cjs/shared/utils/themeUtils.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Theme Utility Functions
+ *
+ * Consolidated theme utilities for normalizing and handling color schemes
+ * across the OxyServices ecosystem.
+ *
+ * @module shared/utils/themeUtils
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSystemColorScheme = exports.systemPrefersDarkMode = exports.getOppositeTheme = exports.normalizeColorScheme = exports.normalizeTheme = void 0;
+/**
+ * Normalizes a theme value to ensure it's always 'light' or 'dark'.
+ *
+ * @param theme - Theme value (may be 'light' | 'dark' | string | undefined)
+ * @returns Normalized 'light' | 'dark' theme (defaults to 'light')
+ *
+ * @example
+ * ```ts
+ * normalizeTheme('dark');     // 'dark'
+ * normalizeTheme('light');    // 'light'
+ * normalizeTheme('unknown');  // 'light'
+ * normalizeTheme(undefined);  // 'light'
+ * normalizeTheme(null);       // 'light'
+ * ```
+ */
+const normalizeTheme = (theme) => theme === 'light' || theme === 'dark' ? theme : 'light';
+exports.normalizeTheme = normalizeTheme;
+/**
+ * Normalizes a color scheme value with optional fallback chain.
+ *
+ * Handles null/undefined cases from React Native's useColorScheme() hook
+ * with a proper fallback chain.
+ *
+ * @param colorScheme - The color scheme from useColorScheme() hook (may be null/undefined)
+ * @param theme - Optional theme prop as fallback
+ * @returns Normalized 'light' | 'dark' color scheme
+ *
+ * @example
+ * ```ts
+ * // In a React Native component:
+ * const systemScheme = useColorScheme(); // might be null
+ * const colorScheme = normalizeColorScheme(systemScheme, props.theme);
+ *
+ * normalizeColorScheme('dark', 'light');      // 'dark'
+ * normalizeColorScheme(null, 'dark');         // 'dark'
+ * normalizeColorScheme(undefined, undefined); // 'light'
+ * ```
+ */
+const normalizeColorScheme = (colorScheme, theme) => {
+    if (colorScheme === 'light' || colorScheme === 'dark') {
+        return colorScheme;
+    }
+    if (theme === 'light' || theme === 'dark') {
+        return theme;
+    }
+    return 'light';
+};
+exports.normalizeColorScheme = normalizeColorScheme;
+/**
+ * Gets the opposite theme value.
+ *
+ * @param theme - Current theme value
+ * @returns The opposite theme ('light' → 'dark', 'dark' → 'light')
+ *
+ * @example
+ * ```ts
+ * getOppositeTheme('light'); // 'dark'
+ * getOppositeTheme('dark');  // 'light'
+ * ```
+ */
+const getOppositeTheme = (theme) => theme === 'light' ? 'dark' : 'light';
+exports.getOppositeTheme = getOppositeTheme;
+/**
+ * Checks if the system prefers dark mode.
+ *
+ * This function only works in browser environments.
+ * Returns false in non-browser environments (Node.js, React Native).
+ *
+ * @returns true if system prefers dark mode, false otherwise
+ *
+ * @example
+ * ```ts
+ * if (systemPrefersDarkMode()) {
+ *   setTheme('dark');
+ * }
+ * ```
+ */
+const systemPrefersDarkMode = () => {
+    if (typeof window === 'undefined')
+        return false;
+    return window.matchMedia?.('(prefers-color-scheme: dark)').matches ?? false;
+};
+exports.systemPrefersDarkMode = systemPrefersDarkMode;
+/**
+ * Gets the system's preferred color scheme.
+ *
+ * @returns 'dark' if system prefers dark mode, 'light' otherwise
+ *
+ * @example
+ * ```ts
+ * const theme = getSystemColorScheme();
+ * ```
+ */
+const getSystemColorScheme = () => (0, exports.systemPrefersDarkMode)() ? 'dark' : 'light';
+exports.getSystemColorScheme = getSystemColorScheme;

package/dist/cjs/utils/accountCacheSweep.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * THE enumeration of `OxyServices` GET-cache keys that serve the ACCOUNT FOREST
+ * — the caller's accessible accounts, as lists and as individual detail rows —
+ * and the one sweep that clears them.
+ *
+ * WHY THIS IS NOT A METHOD ON THE ACCOUNTS MIXIN
+ * ---------------------------------------------
+ * `AccountNode.account` is a whole `User`, so a forest read embeds the very
+ * profile the identity reads serve. That makes an IDENTITY write a writer of
+ * these keys too: `updateProfile` edits the caller's own personal account,
+ * which is a row in `GET /accounts` and is its own `GET /accounts/<id>`. Leave
+ * those cached and the account switcher keeps drawing the pre-edit name and
+ * picture for the full TTL, against a perfectly healthy server.
+ *
+ * The mixins compose into one class at runtime but are typed one at a time, so
+ * the user mixin cannot call a method the accounts mixin owns. The key list
+ * therefore lives here, once, and every writer calls {@link
+ * evictOxyAccountForestCache} — exactly like the identity key list in
+ * `identityCacheSweep`, which the accounts mixin already calls for the
+ * mirror-image case (an account write staling the identity reads). The
+ * alternative — a second hand-written copy of these keys in the other mixin —
+ * is the drift that shipped the two stale-profile bugs `identityCacheSweep`
+ * documents.
+ *
+ * WHY THE LIST NEEDS A PREFIX AND THE DETAIL DOES NOT
+ * --------------------------------------------------
+ * `listAccounts({tree?})` keys the flat list as `GET:/accounts` and every
+ * option variant as `GET:/accounts?<query>` (the query string is part of the
+ * URL, hence of the key), and a writer cannot enumerate which variants a caller
+ * has read. The detail key, by contrast, is derivable from the account id the
+ * writer already holds.
+ *
+ * The `GET:/accounts?` prefix matches ONLY the query-string list variants —
+ * never `GET:/accounts/<id>` or its `…/members`, `…/credentials`, `…/children`
+ * sub-resources, which are the accounts mixin's own business and stay there.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OXY_ACCOUNT_PER_ACCOUNT_CACHE_PREFIX = exports.OXY_ACCOUNT_LIST_CACHE_QUERY_PREFIX = exports.OXY_ACCOUNT_LIST_CACHE_KEY = void 0;
+exports.oxyAccountDetailCacheKey = oxyAccountDetailCacheKey;
+exports.evictOxyAccountForestCache = evictOxyAccountForestCache;
+/** The cache key `listAccounts()` reads under with no options. */
+exports.OXY_ACCOUNT_LIST_CACHE_KEY = 'GET:/accounts';
+/**
+ * The prefix covering every option-carrying `listAccounts(opts)` variant
+ * (`?tree=true`, …), none of which a writer can enumerate.
+ */
+exports.OXY_ACCOUNT_LIST_CACHE_QUERY_PREFIX = 'GET:/accounts?';
+/**
+ * Prefix covering every per-account sub-resource cache key
+ * (`GET:/accounts/<id>`, `…/members`, `…/credentials`, `…/children`). A
+ * membership mutation on an ancestor must sweep ALL of these, not only the
+ * account named in the path: descendant member rosters embed inherited rows
+ * resolved from that ancestor, and the writer cannot enumerate which descendant
+ * ids a caller has already read. The trailing slash deliberately excludes the
+ * forest list keys (`GET:/accounts`, `GET:/accounts?…`) documented above.
+ */
+exports.OXY_ACCOUNT_PER_ACCOUNT_CACHE_PREFIX = 'GET:/accounts/';
+/**
+ * Build the exact cache key `getAccount(accountId)` reads under.
+ */
+function oxyAccountDetailCacheKey(accountId) {
+    return `GET:/accounts/${encodeURIComponent(accountId)}`;
+}
+/**
+ * Sweep an `OxyServices` GET response cache of the account forest.
+ *
+ * @param oxy       - Anything exposing the SDK's two eviction methods.
+ * @param accountId - The account whose detail row to drop as well. Optional: a
+ *                    writer that changed the SHAPE of the forest rather than one
+ *                    account in it (create, archive, ownership transfer) has no
+ *                    detail row to name, and clears only the lists.
+ */
+function evictOxyAccountForestCache(oxy, accountId) {
+    oxy.clearCacheEntry(exports.OXY_ACCOUNT_LIST_CACHE_KEY);
+    oxy.clearCacheByPrefix(exports.OXY_ACCOUNT_LIST_CACHE_QUERY_PREFIX);
+    if (accountId) {
+        oxy.clearCacheEntry(oxyAccountDetailCacheKey(accountId));
+    }
+}

package/dist/cjs/utils/accountUtils.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * Shared account types and pure helper functions.
+ * Used by the @oxy.so/services account stores (Expo/RN and RN-Web).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccountColor = exports.createQuickAccount = exports.buildAccountsArray = exports.getAccountFallbackHandle = exports.getAccountDisplayName = exports.formatPublicKeyHandle = void 0;
+const i18n_1 = require("../i18n");
+const userHandle_1 = require("./userHandle");
+/**
+ * Truncate a long public key for display, e.g. `0x12345678…`.
+ * Falls back to the raw key if it's too short to truncate.
+ */
+const formatPublicKeyHandle = (publicKey) => {
+    const cleaned = publicKey.startsWith('0x') ? publicKey.slice(2) : publicKey;
+    if (cleaned.length <= 8)
+        return `0x${cleaned}`;
+    return `0x${cleaned.slice(0, 8)}…`;
+};
+exports.formatPublicKeyHandle = formatPublicKeyHandle;
+/**
+ * Resolve a friendly display name for a user.
+ *
+ * Order of preference:
+ *  1. `name.displayName` from the API user contract.
+ *  2. `name.full`, or composed `name.first name.last` for local unsaved shapes.
+ *  3. `name` when passed as a plain string by local non-DTO call sites.
+ *  4. pre-normalized account-row `displayName`.
+ *  5. `username`
+ *  6. `Account 0x12345678…` (derived from publicKey, when present)
+ *  7. Translated fallback (e.g. "Unnamed")
+ *
+ * The translation key `common.unnamed` is used for the final fallback. If the
+ * caller does not pass a locale, the default English translation is used.
+ */
+const getAccountDisplayName = (user, locale) => {
+    if (!user)
+        return (0, i18n_1.translate)(locale, 'common.unnamed');
+    const { name, displayName, username, publicKey } = user;
+    if (name && typeof name === 'object') {
+        if (typeof name.displayName === 'string' && name.displayName.trim()) {
+            return name.displayName.trim();
+        }
+        if (typeof name.full === 'string' && name.full.trim())
+            return name.full.trim();
+        const first = typeof name.first === 'string' ? name.first.trim() : '';
+        const last = typeof name.last === 'string' ? name.last.trim() : '';
+        const composed = [first, last].filter(Boolean).join(' ').trim();
+        if (composed)
+            return composed;
+    }
+    else if (typeof name === 'string' && name.trim()) {
+        return name.trim();
+    }
+    if (typeof displayName === 'string' && displayName.trim())
+        return displayName.trim();
+    if (typeof username === 'string' && username.trim())
+        return username.trim();
+    if (typeof publicKey === 'string' && publicKey.length > 0) {
+        return (0, i18n_1.translate)(locale, 'common.accountFallback', {
+            handle: (0, exports.formatPublicKeyHandle)(publicKey),
+        });
+    }
+    return (0, i18n_1.translate)(locale, 'common.unnamed');
+};
+exports.getAccountDisplayName = getAccountDisplayName;
+/**
+ * Resolve a `@handle` style identifier for a user.
+ *
+ * Returns the bare username when present (without the `@`), otherwise a
+ * truncated public-key handle (`0x12345678…`), or `undefined` when neither is
+ * available — callers can decide whether to hide the line entirely.
+ */
+const getAccountFallbackHandle = (user) => {
+    if (!user)
+        return undefined;
+    if (typeof user.username === 'string' && user.username.trim())
+        return user.username.trim();
+    if (typeof user.publicKey === 'string' && user.publicKey.length > 0) {
+        return (0, exports.formatPublicKeyHandle)(user.publicKey);
+    }
+    return undefined;
+};
+exports.getAccountFallbackHandle = getAccountFallbackHandle;
+/**
+ * Build an ordered array of QuickAccounts from a map and order list.
+ */
+const buildAccountsArray = (accounts, order) => {
+    const result = [];
+    for (const id of order) {
+        const account = accounts[id];
+        if (account)
+            result.push(account);
+    }
+    return result;
+};
+exports.buildAccountsArray = buildAccountsArray;
+/**
+ * Create a QuickAccount from user data returned by the API.
+ *
+ * @param sessionId - Session identifier
+ * @param userData - Raw user object from the API
+ * @param existingAccount - Previously cached account (to preserve avatarUrl if unchanged)
+ * @param getFileDownloadUrl - Function to generate avatar download URL from file ID
+ */
+const createQuickAccount = (sessionId, userData, existingAccount, getFileDownloadUrl) => {
+    const nameObj = userData.name && typeof userData.name === 'object' ? userData.name : undefined;
+    const apiDisplayName = typeof nameObj?.displayName === 'string' ? nameObj.displayName.trim() : '';
+    const displayName = apiDisplayName ||
+        (0, userHandle_1.getNormalizedUserHandle)(userData) ||
+        (0, exports.getAccountDisplayName)(null);
+    const userId = userData.id || (typeof userData._id === 'string' ? userData._id : userData._id?.toString());
+    // Preserve existing avatarUrl if avatar hasn't changed (prevents image reload)
+    let avatarUrl;
+    const avatar = userData.avatar ?? undefined;
+    if (existingAccount && existingAccount.avatar === avatar && existingAccount.avatarUrl) {
+        avatarUrl = existingAccount.avatarUrl;
+    }
+    else if (avatar && getFileDownloadUrl) {
+        avatarUrl = getFileDownloadUrl(avatar, 'thumb');
+    }
+    return {
+        sessionId,
+        userId,
+        username: userData.username || '',
+        displayName,
+        avatar,
+        avatarUrl,
+    };
+};
+exports.createQuickAccount = createQuickAccount;
+/**
+ * Return the account's preferred Bloom color preset, or `null` if it has no
+ * preference. Centralises the `color ?? null` normalisation so consumers can
+ * drive per-account theming without duplicating the nullish-handling.
+ */
+const getAccountColor = (account) => {
+    return account.color ?? null;
+};
+exports.getAccountColor = getAccountColor;

package/dist/cjs/utils/activityId.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBrowserActivityIdHeader = void 0;
+/** @deprecated Import from `@oxy.so/telemetry/browser` in new code. */
+var browser_1 = require("@oxy.so/telemetry/browser");
+Object.defineProperty(exports, "getBrowserActivityIdHeader", { enumerable: true, get: function () { return browser_1.getBrowserActivityIdHeader; } });

package/dist/cjs/utils/apiUtils.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * Utility functions for common API patterns
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildQueryParams = buildQueryParams;
+exports.buildSearchParams = buildSearchParams;
+exports.buildUrl = buildUrl;
+exports.buildPaginationParams = buildPaginationParams;
+exports.safeJsonParse = safeJsonParse;
+/**
+ * Build a plain query-parameter record from an object, stringifying values and
+ * dropping `undefined`/`null` entries.
+ *
+ * This is the shape `OxyServices.makeRequest` expects for a GET's `params`:
+ * `HttpService` inspects it with `Object.keys(...)` (both to decide whether to
+ * append a query string and to build the request's cache key), and
+ * `Object.keys(new URLSearchParams({ limit: '20' }))` is `[]` — a
+ * `URLSearchParams` exposes its entries through iterator methods, never as own
+ * enumerable properties. Passing one to `makeRequest` therefore silently drops
+ * the whole query string. Always hand `makeRequest` a plain record.
+ *
+ * Generic over the input object rather than taking `Record<string, unknown>`,
+ * because a TypeScript `interface` (`PaginationParams`, `FollowGraphParams`, …)
+ * has no implicit index signature and so is not assignable to that type.
+ */
+function buildQueryParams(params) {
+    const query = {};
+    // Widening the value to `unknown` is always sound; the default overload of
+    // `Object.entries` would otherwise infer `any` here.
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null) {
+            query[key] = String(value);
+        }
+    }
+    return query;
+}
+/**
+ * Build URL search parameters from an object.
+ *
+ * For building a URL string only — see {@link buildQueryParams} for the shape
+ * `makeRequest` needs.
+ *
+ * @param params Object with parameter key-value pairs
+ * @returns URLSearchParams instance
+ */
+function buildSearchParams(params) {
+    return new URLSearchParams(buildQueryParams(params));
+}
+/**
+ * Build URL with search parameters
+ * @param baseUrl Base URL
+ * @param params Object with parameter key-value pairs
+ * @returns Complete URL with search parameters
+ */
+function buildUrl(baseUrl, params) {
+    if (!params)
+        return baseUrl;
+    const searchParams = buildSearchParams(params);
+    const queryString = searchParams.toString();
+    return queryString ? `${baseUrl}?${queryString}` : baseUrl;
+}
+/**
+ * Build pagination query parameters.
+ *
+ * Returns a plain record — NOT a `URLSearchParams` — because that is the only
+ * shape `makeRequest`/`HttpService` can read. See {@link buildQueryParams}.
+ *
+ * @param params Pagination parameters
+ * @returns Query record with pagination
+ */
+function buildPaginationParams(params) {
+    return buildQueryParams(params);
+}
+/**
+ * Safe JSON parsing with error handling
+ * @param data Data to parse
+ * @param fallback Fallback value if parsing fails
+ * @returns Parsed data or fallback
+ */
+function safeJsonParse(data, fallback) {
+    if (typeof data === 'string') {
+        try {
+            return JSON.parse(data);
+        }
+        catch {
+            return fallback;
+        }
+    }
+    return data;
+}

package/dist/cjs/utils/asyncUtils.js

@@ -0,0 +1,222 @@
+"use strict";
+/**
+ * Async utilities for common asynchronous patterns and error handling
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = void 0;
+exports.withErrorHandling = withErrorHandling;
+exports.parallelWithErrorHandling = parallelWithErrorHandling;
+exports.retryAsync = retryAsync;
+exports.debounceAsync = debounceAsync;
+exports.throttleAsync = throttleAsync;
+exports.sequentialWithProgress = sequentialWithProgress;
+exports.batchAsync = batchAsync;
+exports.createCancellableAsync = createCancellableAsync;
+exports.withTimeout = withTimeout;
+exports.withLoadingState = withLoadingState;
+exports.retryOnError = retryOnError;
+const logger_1 = require("../logger");
+/**
+ * Wrapper for async operations with automatic error handling
+ * Returns null on error instead of throwing
+ */
+async function withErrorHandling(operation, errorHandler, context) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (errorHandler) {
+            errorHandler(error);
+        }
+        else {
+            logger_1.logger.error(`Error in ${context || 'operation'}`, error instanceof Error ? error : new Error(String(error)), {
+                component: 'asyncUtils',
+                method: 'withErrorHandling',
+            });
+        }
+        return null;
+    }
+}
+/**
+ * Execute multiple async operations in parallel with error handling
+ */
+async function parallelWithErrorHandling(operations, errorHandler) {
+    const results = await Promise.allSettled(operations.map((op, index) => withErrorHandling(op, error => errorHandler?.(error, index))));
+    return results.map(result => result.status === 'fulfilled' ? result.value : null);
+}
+/**
+ * Extract an HTTP status code from an error value, tolerating both the
+ * axios-style nested shape (`error.response.status`) and the flat shape
+ * produced by {@link handleHttpError} / fetch-based clients (`error.status`).
+ *
+ * Centralising this lookup prevents retry predicates from silently falling
+ * through when one of the two shapes is missing, which previously caused
+ * @oxy.so/core to retry 4xx responses and turn sub-10ms failures into
+ * multi-second stalls for every missing-resource lookup.
+ */
+function extractHttpStatus(error) {
+    if (!error || typeof error !== 'object')
+        return undefined;
+    const candidate = error;
+    const flat = candidate.status;
+    if (typeof flat === 'number' && Number.isFinite(flat))
+        return flat;
+    const nested = candidate.response?.status;
+    if (typeof nested === 'number' && Number.isFinite(nested))
+        return nested;
+    return undefined;
+}
+/**
+ * Retry an async operation with exponential backoff
+ *
+ * By default, does not retry on 4xx errors (client errors). The default
+ * predicate accepts both the axios-style `error.response.status` and the
+ * flat `error.status` shape produced by {@link handleHttpError}, so callers
+ * never accidentally retry a deterministic client failure.
+ *
+ * Use the `shouldRetry` callback to customize retry behavior.
+ */
+async function retryAsync(operation, maxRetries = 3, baseDelay = 1000, shouldRetry) {
+    let lastError;
+    // Default shouldRetry: don't retry on 4xx errors (client errors).
+    // Checks BOTH `error.status` (flat shape from handleHttpError / fetch
+    // clients) AND `error.response.status` (axios-style shape) so neither
+    // representation can leak a client error into the retry loop.
+    const defaultShouldRetry = (error) => {
+        const status = extractHttpStatus(error);
+        if (status !== undefined && status >= 400 && status < 500) {
+            return false;
+        }
+        return true;
+    };
+    const retryCheck = shouldRetry || defaultShouldRetry;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === maxRetries) {
+                break;
+            }
+            if (!retryCheck(error)) {
+                break;
+            }
+            // Calculate delay with exponential backoff and jitter
+            const delay = baseDelay * Math.pow(2, attempt) + Math.random() * 1000;
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+    }
+    throw lastError;
+}
+/**
+ * Debounce async function calls
+ */
+function debounceAsync(func, delay) {
+    let timeoutId;
+    return (...args) => {
+        return new Promise((resolve, reject) => {
+            clearTimeout(timeoutId);
+            timeoutId = setTimeout(async () => {
+                try {
+                    const result = await func(...args);
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }, delay);
+        });
+    };
+}
+/**
+ * Throttle async function calls
+ */
+function throttleAsync(func, limit, interval) {
+    let inThrottle = false;
+    let lastPromise = null;
+    return (...args) => {
+        if (inThrottle) {
+            return lastPromise;
+        }
+        inThrottle = true;
+        lastPromise = func(...args);
+        setTimeout(() => {
+            inThrottle = false;
+        }, interval);
+        return lastPromise;
+    };
+}
+/**
+ * Execute async operations sequentially with progress tracking
+ */
+async function sequentialWithProgress(operations, onProgress) {
+    const results = [];
+    for (let i = 0; i < operations.length; i++) {
+        const result = await operations[i]();
+        results.push(result);
+        onProgress?.(i + 1, operations.length);
+    }
+    return results;
+}
+/**
+ * Batch async operations
+ */
+async function batchAsync(items, batchSize, processor) {
+    for (let i = 0; i < items.length; i += batchSize) {
+        const batch = items.slice(i, i + batchSize);
+        await processor(batch);
+    }
+}
+/**
+ * Create a cancellable async operation
+ */
+function createCancellableAsync(operation) {
+    let abortController = null;
+    return {
+        execute: async () => {
+            abortController = new AbortController();
+            return await operation(abortController.signal);
+        },
+        cancel: () => {
+            abortController?.abort();
+        }
+    };
+}
+/**
+ * Timeout wrapper for async operations
+ */
+async function withTimeout(operation, timeoutMs, timeoutMessage) {
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new Error(timeoutMessage || `Operation timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+    return Promise.race([operation, timeoutPromise]);
+}
+/**
+ * Execute async operation with loading state
+ */
+async function withLoadingState(operation, setLoading) {
+    setLoading(true);
+    try {
+        return await operation();
+    }
+    finally {
+        setLoading(false);
+    }
+}
+/**
+ * Create a promise that resolves after a delay
+ */
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+exports.delay = delay;
+/**
+ * Execute async operation with retry on specific errors
+ */
+async function retryOnError(operation, retryableErrors, maxRetries = 3) {
+    return retryAsync(operation, maxRetries, 1000, (error) => {
+        const errorCode = error?.code || error?.status || error?.message;
+        return retryableErrors.includes(errorCode);
+    });
+}