Method runner

static/js/utils.js:320–402

()

        }

        const runner = async () => {
            for (let attempt = 0; attempt <= retryCount; attempt += 1) {
                let timedOut = false;
                let timeoutId = null;
                const controller = new AbortController();

                if (requestKey && cancelPrevious) {
                    const previousController = this.inflightRequests.get(requestKey);
                    if (previousController) {
                        previousController.__cancelReason = 'request_replaced';
                        previousController.abort();
                    }
                }
                if (requestKey) {
                    this.inflightRequests.set(requestKey, controller);
                }

                if (externalSignal) {
                    if (externalSignal.aborted) {
                        controller.abort();
                    } else {
                        externalSignal.addEventListener('abort', () => controller.abort(), { once: true });
                    }
                }

                if (effectiveTimeoutMs > 0) {
                    timeoutId = setTimeout(() => {
                        timedOut = true;
                        controller.__cancelReason = 'timeout';
                        controller.abort();
                    }, effectiveTimeoutMs);
                }

                try {
                    if (!this.networkOnline && requestPriority === 'low') {
                        const offlineError = new Error('网络离线，后台请求已跳过');
                        offlineError.name = 'NetworkOfflineError';
                        throw offlineError;
                    }

                    const response = await fetch(url, { ...finalOptions, signal: controller.signal });
                    const data = await response.json().catch(() => ({}));

                    if (!response.ok) {
                        const error = new Error(data.detail || `HTTP ${response.status}`);
                        error.response = response;
                        error.data = data;
                        throw error;
                    }

                    return data;
                } catch (error) {
                    const isAbortError = error?.name === 'AbortError';
                    const cancelReason = controller.__cancelReason || '';
                    const isExpectedAbort = isAbortError && (cancelReason === 'request_replaced' || externalSignal?.aborted);
                    const isTimeoutError = isAbortError && (timedOut || cancelReason === 'timeout');
                    const isOfflineError = error?.name === 'NetworkOfflineError';
                    const isNetworkError = !error.response && !isAbortError && !isOfflineError;