fzkit 0.1.0

package/dist/create-http-client-pzpOS1bC.mjs

@@ -0,0 +1,700 @@
+import axios, { AxiosError, AxiosHeaders } from "axios";
+//#region src/http-client/constants.ts
+/**
+* 包内默认常量。
+*
+* @internal
+*/
+/** Default error messages */
+const DEFAULT_MESSAGES = {
+	refreshTokenExpired: "Refresh token is invalid or expired",
+	loginExpired: "Login session has expired",
+	refreshDisabled: "Refresh token flow is not enabled"
+};
+/** Default retry delay cap (ms) */
+const DEFAULT_RETRY_DELAY_CAP = 3e4;
+//#endregion
+//#region src/http-client/utils/common.ts
+/**
+* 判断 config 是否已通过 signal / cancelToken 取消。
+*/
+const isCanceled = (config) => {
+	if (config.signal?.aborted) return true;
+	try {
+		config.cancelToken?.throwIfRequested();
+	} catch {
+		return true;
+	}
+	return false;
+};
+/**
+* 归一化 timeout：仅正数生效，其余视为 0（无超时）。
+*/
+const normalizeTimeoutMs = (timeout) => typeof timeout === "number" && timeout > 0 ? timeout : 0;
+/**
+* 构造 axios CanceledError。
+*/
+const createCanceledError = (config) => new axios.CanceledError("canceled", config);
+/**
+* 构造 axios timeout 错误（ECONNABORTED）。
+*/
+const createTimeoutError = (config, timeoutMs) => new AxiosError(`timeout of ${timeoutMs}ms exceeded`, AxiosError.ECONNABORTED, config);
+/**
+* 深拷贝任意值；不可 clone 时回退浅拷贝。
+*/
+const cloneDeep = (value) => {
+	if (value == null || typeof value !== "object") return value;
+	try {
+		return structuredClone(value);
+	} catch {
+		if (Array.isArray(value)) return [...value];
+		return { ...value };
+	}
+};
+/**
+* 订阅 config 的取消事件（signal / cancelToken），返回取消订阅函数。
+*/
+const subscribeCancel = (config, onCancel) => {
+	const signal = config.signal;
+	const onAbort = () => onCancel();
+	signal?.addEventListener?.("abort", onAbort);
+	const cancelToken = config.cancelToken;
+	let cancelListener;
+	if (cancelToken?.subscribe) {
+		cancelListener = () => onCancel();
+		cancelToken.subscribe(cancelListener);
+	} else if (cancelToken?.promise) cancelToken.promise.then(onCancel, () => {});
+	return () => {
+		signal?.removeEventListener?.("abort", onAbort);
+		if (cancelToken?.unsubscribe && cancelListener) cancelToken.unsubscribe(cancelListener);
+	};
+};
+//#endregion
+//#region src/http-client/create-dedupe-adapter.ts
+/**
+* 将 shared 错误分叉为绑定当前 consumer config 的独立错误实例。
+* 仅 dedupe 合并路径使用。
+*/
+const forkError = (error, config) => {
+	if (axios.isAxiosError(error)) return new AxiosError(error.message, error.code, config, error.request, error.response ? {
+		...error.response,
+		data: cloneDeep(error.response.data),
+		config
+	} : void 0);
+	if (error instanceof Error) {
+		const forked = new Error(error.message);
+		forked.name = error.name;
+		forked.stack = error.stack;
+		if ("cause" in error) forked.cause = error.cause;
+		return forked;
+	}
+	return error;
+};
+/**
+* adapter 层 in-flight GET 合并。
+*
+* - 共享底层网络 Promise + 内部 AbortController
+* - 每个消费者绑定自己的 config / cancel / timeout
+* - 消费者取消仅为逻辑取消；refCount 归零才物理 abort
+* - shared timeout 取参与者中的 max(timeout)；任一无限则 shared 不强制超时
+* - 成功响应只深拷贝 data，避免消费者互相污染
+*
+* @internal
+*/
+const createDedupeAdapter = ({ underlyingAdapter, dedupeManager, clientDedupeEnabled }) => {
+	const getAdapter = axios.getAdapter;
+	const dispatch = (config) => Promise.resolve(getAdapter(underlyingAdapter, config)(config));
+	const createSharedEntry = (config) => {
+		const controller = new AbortController();
+		const { signal: _signal, cancelToken: _cancelToken, timeout: _timeout, ...rest } = config;
+		const sharedConfig = {
+			...rest,
+			signal: controller.signal,
+			timeout: 0
+		};
+		return {
+			promise: dispatch(sharedConfig),
+			controller,
+			refCount: 0,
+			timeouts: [],
+			maxTimeoutMs: 0,
+			startedAt: Date.now(),
+			closed: false
+		};
+	};
+	const bindConsumer = (entry, config) => new Promise((resolve, reject) => {
+		if (isCanceled(config)) {
+			reject(createCanceledError(config));
+			return;
+		}
+		const timeoutMs = normalizeTimeoutMs(config.timeout);
+		dedupeManager.retain(entry, timeoutMs);
+		let settled = false;
+		let localTimeoutId;
+		const settle = (fn) => {
+			if (settled) return;
+			settled = true;
+			if (localTimeoutId != null) clearTimeout(localTimeoutId);
+			cleanupCancel();
+			dedupeManager.release(entry, timeoutMs);
+			fn();
+		};
+		const onConsumerLeave = (error) => {
+			settle(() => reject(error));
+		};
+		const cleanupCancel = subscribeCancel(config, () => {
+			onConsumerLeave(createCanceledError(config));
+		});
+		if (timeoutMs > 0) localTimeoutId = setTimeout(() => {
+			onConsumerLeave(createTimeoutError(config, timeoutMs));
+		}, timeoutMs);
+		entry.promise.then((response) => {
+			if (isCanceled(config)) {
+				onConsumerLeave(createCanceledError(config));
+				return;
+			}
+			settle(() => resolve({
+				...response,
+				data: cloneDeep(response.data),
+				config
+			}));
+		}, (error) => {
+			if (isCanceled(config)) {
+				onConsumerLeave(createCanceledError(config));
+				return;
+			}
+			if (axios.isCancel(error) || axios.isAxiosError(error) && error.code === AxiosError.ERR_CANCELED) {
+				if (entry.abortReason === "timeout") {
+					onConsumerLeave(createTimeoutError(config, entry.maxTimeoutMs || timeoutMs || 0));
+					return;
+				}
+				onConsumerLeave(createCanceledError(config));
+				return;
+			}
+			settle(() => reject(forkError(error, config)));
+		});
+	});
+	return (config) => {
+		const method = (config.method ?? "get").toLowerCase();
+		const enabled = config.dedupePolicy?.enabled ?? clientDedupeEnabled;
+		if (method !== "get" || !enabled) return dispatch(config);
+		if (isCanceled(config)) return Promise.reject(createCanceledError(config));
+		const key = dedupeManager.getKey(config);
+		let entry = dedupeManager.getPending(key);
+		if (!entry) {
+			entry = createSharedEntry(config);
+			dedupeManager.setPending(key, entry);
+		}
+		return bindConsumer(entry, config);
+	};
+};
+//#endregion
+//#region src/http-client/dedupe-manager.ts
+/**
+* 请求合并管理器。
+* 仅合并仍在进行中的相同请求（in-flight coalesce）。
+*
+* @internal
+*/
+var DedupeManager = class {
+	pending = /* @__PURE__ */ new Map();
+	generateKey;
+	constructor(generateKey) {
+		this.generateKey = generateKey ?? this.defaultGenerateKey;
+	}
+	/**
+	* 默认的 key 生成器。
+	* 由 lower-case method + baseURL + url + 稳定序列化 params + headersProvider 快照组成。
+	*/
+	defaultGenerateKey(config) {
+		return `${(config.method ?? "get").toLowerCase()}:${config.baseURL ?? ""}:${config.url ?? ""}:${this.stableSerialize(config.params)}:${this.stableSerialize(config.__dedupeProviderHeaders ?? null)}`;
+	}
+	stableSerialize(value) {
+		if (value == null) return "";
+		return JSON.stringify(this.normalizeForSerialize(value, /* @__PURE__ */ new WeakSet()));
+	}
+	normalizeForSerialize(value, seen) {
+		if (value == null || typeof value !== "object") return value;
+		if (value instanceof Date) return {
+			__type: "Date",
+			value: value.toISOString()
+		};
+		if (value instanceof URLSearchParams) return {
+			__type: "URLSearchParams",
+			value: Array.from(value.entries()).sort(([a], [b]) => a.localeCompare(b))
+		};
+		if (value instanceof Set) return {
+			__type: "Set",
+			value: Array.from(value).map((item) => this.normalizeForSerialize(item, seen)).map((item) => JSON.stringify(item)).sort((a, b) => a.localeCompare(b)).map((item) => JSON.parse(item))
+		};
+		if (value instanceof Map) return {
+			__type: "Map",
+			value: Array.from(value.entries()).map(([key, nested]) => [this.normalizeForSerialize(key, seen), this.normalizeForSerialize(nested, seen)]).map(([key, nested]) => [
+				JSON.stringify(key),
+				key,
+				nested
+			]).sort(([a], [b]) => a.localeCompare(b)).map(([, key, nested]) => [key, nested])
+		};
+		if (seen.has(value)) throw new TypeError("Circular structure in dedupe key serialization");
+		seen.add(value);
+		if (Array.isArray(value)) {
+			const normalized = value.map((item) => this.normalizeForSerialize(item, seen));
+			seen.delete(value);
+			return normalized;
+		}
+		const normalizedObject = Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, nested]) => [key, this.normalizeForSerialize(nested, seen)]));
+		seen.delete(value);
+		return normalizedObject;
+	}
+	/**
+	* 生成请求的唯一 key。
+	*/
+	getKey(config) {
+		return this.generateKey(config);
+	}
+	/**
+	* 读取可 join 的 pending entry。
+	* closed 的 entry 视为不可复用。
+	*/
+	getPending(key) {
+		const entry = this.pending.get(key);
+		if (!entry || entry.closed) return null;
+		return entry;
+	}
+	/**
+	* 注册新的 shared 请求。
+	*/
+	setPending(key, entry) {
+		this.pending.set(key, entry);
+		const cleanup = () => {
+			this.clearTimer(entry);
+			if (this.pending.get(key) === entry) this.pending.delete(key);
+		};
+		entry.promise.then(cleanup, cleanup);
+	}
+	/**
+	* consumer 加入 shared。
+	* @param timeoutMs 0 表示无超时
+	*/
+	retain(entry, timeoutMs) {
+		entry.refCount += 1;
+		entry.timeouts.push(timeoutMs);
+		this.recomputeTimeout(entry);
+	}
+	/**
+	* consumer 离开 shared。
+	* 当 refCount 归零时 abort 底层请求并标记 closed。
+	*/
+	release(entry, timeoutMs) {
+		const index = entry.timeouts.indexOf(timeoutMs);
+		if (index >= 0) entry.timeouts.splice(index, 1);
+		entry.refCount = Math.max(0, entry.refCount - 1);
+		if (entry.closed) return;
+		if (entry.refCount === 0) {
+			this.abortEntry(entry, "release");
+			return;
+		}
+		this.recomputeTimeout(entry);
+	}
+	recomputeTimeout(entry) {
+		if (entry.closed) return;
+		if (entry.timeouts.some((item) => item <= 0)) {
+			entry.maxTimeoutMs = 0;
+			this.clearTimer(entry);
+			return;
+		}
+		const nextMax = entry.timeouts.length > 0 ? Math.max(...entry.timeouts) : 0;
+		entry.maxTimeoutMs = nextMax;
+		if (nextMax <= 0) {
+			this.clearTimer(entry);
+			return;
+		}
+		const remaining = nextMax - (Date.now() - entry.startedAt);
+		this.clearTimer(entry);
+		if (remaining <= 0) {
+			this.abortEntry(entry, "timeout");
+			return;
+		}
+		entry.timeoutId = setTimeout(() => {
+			this.abortEntry(entry, "timeout");
+		}, remaining);
+	}
+	abortEntry(entry, reason) {
+		if (entry.closed) return;
+		entry.closed = true;
+		entry.abortReason = reason;
+		this.clearTimer(entry);
+		if (!entry.controller.signal.aborted) entry.controller.abort();
+	}
+	clearTimer(entry) {
+		if (entry.timeoutId != null) {
+			clearTimeout(entry.timeoutId);
+			entry.timeoutId = void 0;
+		}
+	}
+};
+//#endregion
+//#region src/http-client/token-refresh-manager.ts
+/** @internal 冷却期内跳过刷新时的哨兵值，不对业务侧开放。 */
+const REFRESH_SKIPPED = Symbol("REFRESH_SKIPPED");
+var TokenRefreshManager = class {
+	refreshingPromise = null;
+	lastRefreshTime = null;
+	cooldownMs;
+	constructor(cooldownMs = 15e3) {
+		this.cooldownMs = cooldownMs;
+	}
+	/** @internal 供 createHttpClient 内部调用。 */
+	async runRefresh(task) {
+		if (this.lastRefreshTime !== null && Date.now() - this.lastRefreshTime < this.cooldownMs) return REFRESH_SKIPPED;
+		if (!this.refreshingPromise) this.refreshingPromise = (async () => {
+			try {
+				const result = await task();
+				this.lastRefreshTime = Date.now();
+				return result;
+			} finally {
+				this.refreshingPromise = null;
+			}
+		})();
+		return this.refreshingPromise;
+	}
+};
+//#endregion
+//#region src/http-client/utils/error.ts
+/**
+* 错误归一化与 onError 调用辅助。
+*
+* @internal
+*/
+/**
+* 将任意值标准化为 Error 实例。
+*/
+const normalizeError = (error) => {
+	if (error instanceof Error) return error;
+	if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") return new Error(error.message);
+	try {
+		return new Error(JSON.stringify(error));
+	} catch {
+		return new Error(String(error));
+	}
+};
+/**
+* 分叉错误实例，避免共享 Promise rejection 让多个消费者拿到同一引用。
+*/
+const cloneError = (error) => {
+	if (axios.isAxiosError(error)) return new AxiosError(error.message, error.code, error.config, error.request, error.response ? {
+		...error.response,
+		data: cloneDeep(error.response.data)
+	} : void 0);
+	if (error instanceof Error) {
+		const forked = new Error(error.message);
+		forked.name = error.name;
+		forked.stack = error.stack;
+		if ("cause" in error) forked.cause = error.cause;
+		for (const key of Object.keys(error)) {
+			if (key === "name" || key === "message" || key === "stack" || key === "cause") continue;
+			try {
+				forked[key] = error[key];
+			} catch {}
+		}
+		return forked;
+	}
+	return error;
+};
+/**
+* 调用错误回调，返回最终错误。
+*/
+const invokeOnError = async (error, context, onError) => {
+	if (!onError) return error;
+	try {
+		return await onError(error, context) ?? error;
+	} catch {
+		return error;
+	}
+};
+//#endregion
+//#region src/http-client/utils/refresh.ts
+/**
+* 默认的重试判断逻辑。
+* 网络错误（AxiosError 无 response）或 5xx 状态码时重试。
+* 用户取消 / 非 AxiosError 不重试。
+*/
+const defaultShouldRetry = (error) => {
+	if (!axios.isAxiosError(error)) return false;
+	if (axios.isCancel(error) || error.code === AxiosError.ERR_CANCELED) return false;
+	if (!error.response) return true;
+	return error.response.status >= 500;
+};
+/**
+* 默认的重试延迟计算。
+* 指数退避：1000 * 2^retryCount，上限 30 秒。
+*/
+const defaultRetryDelay = (retryCount) => {
+	return Math.min(1e3 * Math.pow(2, retryCount), DEFAULT_RETRY_DELAY_CAP);
+};
+/**
+* 解析重试策略，补齐默认值。
+*/
+const resolveRetryPolicy = (retryPolicy) => {
+	if (!retryPolicy) return null;
+	const maxRetries = retryPolicy.maxRetries ?? 0;
+	if (maxRetries <= 0) return null;
+	return {
+		maxRetries,
+		shouldRetry: retryPolicy.shouldRetry ?? defaultShouldRetry,
+		retryDelay: retryPolicy.retryDelay ?? defaultRetryDelay
+	};
+};
+/**
+* 判断是否跳过刷新流程。
+*
+* 匹配规则：
+* - 仅 exact / prefix 路径匹配
+* - 不是任意子串 includes，也不做中间段滑动匹配
+* - 例如 `/auth` 匹配 `/auth`、`/auth/login`
+* - 不匹配 `/user/auth-history`、`/authorization`、`/api/auth/login`
+*/
+const shouldSkipRefresh = (skipRefreshUrls, config) => {
+	const requestUrl = config?.url;
+	if (!requestUrl) return false;
+	const normalizedRequestPath = normalizeRequestPath(requestUrl);
+	return skipRefreshUrls.some((skipUrl) => matchesSkipPath(normalizedRequestPath, skipUrl));
+};
+const normalizeRequestPath = (requestUrl) => {
+	try {
+		return new URL(requestUrl, "http://localhost").pathname || "/";
+	} catch {
+		const withoutQuery = requestUrl.split("?")[0]?.split("#")[0] ?? requestUrl;
+		return withoutQuery.startsWith("/") ? withoutQuery : `/${withoutQuery}`;
+	}
+};
+const matchesSkipPath = (requestPath, skipUrl) => {
+	if (!skipUrl) return false;
+	const skipPath = (skipUrl.startsWith("/") ? skipUrl : `/${skipUrl}`).replace(/\/+$/, "") || "/";
+	const path = requestPath.replace(/\/+$/, "") || "/";
+	return path === skipPath || path.startsWith(`${skipPath}/`);
+};
+/**
+* 默认的刷新失败判断逻辑。
+*/
+const defaultIsRefreshFailure = (error, options) => {
+	if (!axios.isAxiosError(error)) return false;
+	if (!error.response || error.response.status >= 500) return false;
+	const status = error.response.status;
+	const data = error.response.data;
+	return status === options.unauthorizedStatusCode || data?.code !== void 0 && options.refreshFailureCodes.includes(data.code);
+};
+//#endregion
+//#region src/http-client/utils/token.ts
+/**
+* 格式化 token（添加前缀）。
+*/
+const formatAccessToken = (prefix, token) => {
+	const normalizedPrefix = prefix.trim();
+	return normalizedPrefix ? `${normalizedPrefix} ${token}` : token;
+};
+/**
+* 标准化 token 结果，提取 token 和 expiresAt。
+*/
+const normalizeTokenResult = (result) => {
+	if (!result || typeof result === "string") return {
+		token: result ?? "",
+		expiresAt: null
+	};
+	const token = result.token ?? "";
+	const expiresAtValue = result.expiresAt;
+	if (expiresAtValue == null || expiresAtValue === "" || expiresAtValue === 0) return {
+		token,
+		expiresAt: null
+	};
+	const expiresAtDate = new Date(expiresAtValue);
+	if (Number.isNaN(expiresAtDate.getTime())) return {
+		token,
+		expiresAt: null
+	};
+	return {
+		token,
+		expiresAt: expiresAtDate
+	};
+};
+/**
+* 判断 token 是否即将过期。
+*/
+const isTokenExpiringSoon = (expiresAt, refreshBufferMs) => {
+	return Date.now() >= expiresAt.getTime() - refreshBufferMs;
+};
+//#endregion
+//#region src/http-client/create-http-client.ts
+const createHttpClient = (options) => {
+	const resolvedOptions = {
+		accessTokenHeaderName: "Authorization",
+		accessTokenPrefix: "Bearer",
+		refreshFailureCodes: [],
+		unauthorizedStatusCode: 401,
+		errorMessages: {},
+		isRefreshFailure: (error) => defaultIsRefreshFailure(error, {
+			unauthorizedStatusCode: resolvedOptions.unauthorizedStatusCode,
+			refreshFailureCodes: resolvedOptions.refreshFailureCodes
+		}),
+		skipRefreshUrls: [],
+		refreshBufferMs: 0,
+		shouldRefreshByResponse: () => false,
+		...options
+	};
+	const refreshManager = options.refreshManager ?? new TokenRefreshManager(options.refreshCooldownMs);
+	const refreshEnabled = options.refreshAccessToken !== void 0;
+	const resolvedRetryPolicy = resolveRetryPolicy(options.retryPolicy);
+	const clientDedupePolicy = options.dedupePolicy;
+	const clientDedupeEnabled = clientDedupePolicy?.enabled === true;
+	const dedupeManager = new DedupeManager(clientDedupePolicy?.generateKey);
+	const instance = axios.create({
+		timeout: 15 * 1e3,
+		...resolvedOptions.axiosConfig
+	});
+	const originalRequest = instance.request.bind(instance);
+	const replayRequest = (config) => originalRequest(config);
+	instance.defaults.adapter = createDedupeAdapter({
+		underlyingAdapter: instance.defaults.adapter,
+		dedupeManager,
+		clientDedupeEnabled
+	});
+	const handleAuthFailure = async (error) => {
+		await resolvedOptions.onAuthFailure?.(error);
+	};
+	const rejectWithError = async (error, type) => {
+		const finalError = await invokeOnError(normalizeError(error), { type }, resolvedOptions.onError);
+		return Promise.reject(finalError);
+	};
+	const refreshAccessToken = async () => {
+		const requestRefreshAccessToken = resolvedOptions.refreshAccessToken;
+		if (!refreshEnabled || !requestRefreshAccessToken) throw new Error(DEFAULT_MESSAGES.refreshDisabled);
+		const rejectRefreshAuthFailure = async () => {
+			const authError = new Error(resolvedOptions.errorMessages?.refreshTokenExpired ?? DEFAULT_MESSAGES.refreshTokenExpired);
+			await handleAuthFailure(authError);
+			throw await invokeOnError(authError, { type: "refresh" }, resolvedOptions.onError);
+		};
+		try {
+			return await refreshManager.runRefresh(async () => {
+				let result;
+				try {
+					result = await requestRefreshAccessToken();
+				} catch (error) {
+					const normalizedError = normalizeError(error);
+					if (resolvedOptions.isRefreshFailure(error)) await rejectRefreshAuthFailure();
+					throw await invokeOnError(normalizedError, { type: "refresh" }, resolvedOptions.onError);
+				}
+				const { token } = normalizeTokenResult(result);
+				if (!token) await rejectRefreshAuthFailure();
+				return result;
+			});
+		} catch (error) {
+			throw cloneError(error);
+		}
+	};
+	const retryAfterRefresh = async (config) => {
+		if (config._retry) {
+			const authError = new Error(resolvedOptions.errorMessages?.loginExpired ?? DEFAULT_MESSAGES.loginExpired);
+			await handleAuthFailure(authError);
+			throw await invokeOnError(authError, { type: "refresh" }, resolvedOptions.onError);
+		}
+		config._retry = true;
+		const refreshResult = await refreshAccessToken();
+		const { token } = normalizeTokenResult(refreshResult === REFRESH_SKIPPED ? await resolvedOptions.getAccessToken() : refreshResult);
+		if (!token) {
+			const authError = new Error(resolvedOptions.errorMessages?.loginExpired ?? DEFAULT_MESSAGES.loginExpired);
+			await handleAuthFailure(authError);
+			throw await invokeOnError(authError, { type: "refresh" }, resolvedOptions.onError);
+		}
+		const headers = AxiosHeaders.from(config.headers ?? {});
+		headers.set(resolvedOptions.accessTokenHeaderName, formatAccessToken(resolvedOptions.accessTokenPrefix, token));
+		config.headers = headers;
+		config.__tokenInjected = true;
+		config.__headersPrepared = false;
+		return replayRequest(config);
+	};
+	const prepareRequestHeaders = async (config) => {
+		if (config.__headersPrepared) return config;
+		const headersProvider = resolvedOptions.headersProvider;
+		const runtimeHeaders = headersProvider ? await headersProvider() : void 0;
+		config.__dedupeProviderHeaders = runtimeHeaders ? { ...runtimeHeaders } : headersProvider ? {} : null;
+		const headers = AxiosHeaders.from(config.headers ?? {});
+		const refreshedAuth = config._retry ? headers.get(resolvedOptions.accessTokenHeaderName) : void 0;
+		if (runtimeHeaders) headers.set(runtimeHeaders);
+		if (refreshedAuth != null) headers.set(resolvedOptions.accessTokenHeaderName, refreshedAuth);
+		config.headers = headers;
+		if (headers.get(resolvedOptions.accessTokenHeaderName) == null) {
+			const { token, expiresAt } = normalizeTokenResult(await resolvedOptions.getAccessToken());
+			if (token) {
+				if (refreshEnabled && expiresAt && !shouldSkipRefresh(resolvedOptions.skipRefreshUrls, config)) {
+					const bufferMs = resolvedOptions.refreshBufferMs;
+					if (bufferMs > 0 && isTokenExpiringSoon(expiresAt, bufferMs)) refreshAccessToken().catch(() => {});
+				}
+				headers.set(resolvedOptions.accessTokenHeaderName, formatAccessToken(resolvedOptions.accessTokenPrefix, token));
+				config.__tokenInjected = true;
+			}
+		}
+		config.__headersPrepared = true;
+		return config;
+	};
+	instance.interceptors.request.use(async (config) => {
+		return prepareRequestHeaders(config);
+	}, (error) => Promise.reject(error));
+	instance.interceptors.response.use(async (response) => {
+		const config = response.config;
+		if (resolvedOptions.shouldRefreshByResponse(response) && refreshEnabled && !shouldSkipRefresh(resolvedOptions.skipRefreshUrls, config)) return retryAfterRefresh(config);
+		if (resolvedOptions.onBusinessResponse) try {
+			const businessResult = await resolvedOptions.onBusinessResponse(response);
+			if (businessResult instanceof Error) return rejectWithError(businessResult, "request");
+			if (businessResult && typeof businessResult === "object" && "status" in businessResult && "data" in businessResult && "config" in businessResult && "headers" in businessResult && "statusText" in businessResult) return {
+				...businessResult,
+				data: cloneDeep(businessResult.data)
+			};
+		} catch (businessError) {
+			return rejectWithError(businessError, "request");
+		}
+		return response;
+	}, async (error) => {
+		const config = error.config;
+		const normalizedError = normalizeError(error);
+		if (!config) return rejectWithError(normalizedError, "request");
+		if (error.response?.status === resolvedOptions.unauthorizedStatusCode) {
+			if (!refreshEnabled || shouldSkipRefresh(resolvedOptions.skipRefreshUrls, config)) {
+				await handleAuthFailure(normalizedError);
+				return rejectWithError(normalizedError, "request");
+			}
+			try {
+				return await retryAfterRefresh(config);
+			} catch (refreshError) {
+				return Promise.reject(refreshError);
+			}
+		}
+		if (resolvedRetryPolicy) {
+			const retryCount = config.__retryCount ?? 0;
+			try {
+				const shouldRetry = resolvedRetryPolicy.shouldRetry(error, retryCount);
+				if (retryCount < resolvedRetryPolicy.maxRetries && shouldRetry) {
+					const rawDelay = resolvedRetryPolicy.retryDelay(retryCount);
+					const delay = typeof rawDelay === "number" && Number.isFinite(rawDelay) && rawDelay > 0 ? rawDelay : 0;
+					config.__retryCount = retryCount + 1;
+					if (config.__tokenInjected) {
+						const headers = AxiosHeaders.from(config.headers ?? {});
+						headers.delete(resolvedOptions.accessTokenHeaderName);
+						config.headers = headers;
+						delete config.__tokenInjected;
+					}
+					config.__headersPrepared = false;
+					await new Promise((resolve) => setTimeout(resolve, delay));
+					return replayRequest(config);
+				}
+			} catch (policyError) {
+				return rejectWithError(policyError, "request");
+			}
+		}
+		return rejectWithError(normalizedError, "request");
+	});
+	return instance;
+};
+//#endregion
+export { TokenRefreshManager as n, createHttpClient as t };
+
+//# sourceMappingURL=create-http-client-pzpOS1bC.mjs.map