@djvlc/openapi-client-core 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1327 @@
+// src/version.ts
+var SDK_VERSION = true ? "1.0.0" : "0.0.0-dev";
+var SDK_NAME = true ? "@djvlc/openapi-client-core" : "@djvlc/openapi-client-core";
+function getSdkInfo() {
+  return {
+    name: SDK_NAME,
+    version: SDK_VERSION
+  };
+}
+
+// src/errors.ts
+var DjvApiError = class _DjvApiError extends Error {
+  constructor(message, code, status, traceId, details, response) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.traceId = traceId;
+    this.details = details;
+    this.response = response;
+    /** 标识这是一个 API 错误（用于 instanceof 替代方案） */
+    this.isApiError = true;
+    /** 错误名称 */
+    this.name = "DjvApiError";
+    Object.setPrototypeOf(this, _DjvApiError.prototype);
+  }
+  // ============================================================
+  // 增强方法 - P1 优化
+  // ============================================================
+  /**
+   * 是否为认证错误 (401 Unauthorized)
+   */
+  isUnauthorized() {
+    return this.status === 401;
+  }
+  /**
+   * 是否为权限错误 (403 Forbidden)
+   */
+  isForbidden() {
+    return this.status === 403;
+  }
+  /**
+   * 是否为认证相关错误 (401 或 403)
+   */
+  isAuthError() {
+    return this.status === 401 || this.status === 403;
+  }
+  /**
+   * 是否为客户端错误 (4xx)
+   */
+  isClientError() {
+    return this.status >= 400 && this.status < 500;
+  }
+  /**
+   * 是否为服务端错误 (5xx)
+   */
+  isServerError() {
+    return this.status >= 500;
+  }
+  /**
+   * 是否为限流错误 (429 Too Many Requests)
+   */
+  isRateLimited() {
+    return this.status === 429;
+  }
+  /**
+   * 是否为资源未找到 (404 Not Found)
+   */
+  isNotFound() {
+    return this.status === 404;
+  }
+  /**
+   * 是否为请求冲突 (409 Conflict)
+   */
+  isConflict() {
+    return this.status === 409;
+  }
+  /**
+   * 是否为请求验证失败 (400 Bad Request 或 422 Unprocessable Entity)
+   */
+  isValidationError() {
+    return this.status === 400 || this.status === 422;
+  }
+  /**
+   * 获取 Retry-After 头的值（秒）
+   *
+   * 适用于 429 限流响应和 503 服务不可用响应
+   *
+   * @returns 重试等待秒数，如果没有 Retry-After 头则返回 null
+   */
+  getRetryAfter() {
+    const header = this.response?.headers.get("Retry-After");
+    if (!header) return null;
+    const seconds = parseInt(header, 10);
+    if (!isNaN(seconds)) {
+      return seconds;
+    }
+    const date = Date.parse(header);
+    if (!isNaN(date)) {
+      return Math.max(0, Math.ceil((date - Date.now()) / 1e3));
+    }
+    return null;
+  }
+  /**
+   * 获取重试延迟（毫秒）
+   *
+   * 优先使用 Retry-After 头，否则返回默认值
+   *
+   * @param defaultMs 默认延迟毫秒数
+   */
+  getRetryDelayMs(defaultMs = 1e3) {
+    const retryAfter = this.getRetryAfter();
+    return retryAfter !== null ? retryAfter * 1e3 : defaultMs;
+  }
+  // ============================================================
+  // 静态方法
+  // ============================================================
+  /**
+   * 类型保护：判断是否为 DjvApiError
+   */
+  static is(error) {
+    if (error instanceof _DjvApiError) return true;
+    if (error == null || typeof error !== "object") return false;
+    return "isApiError" in error && error.isApiError === true;
+  }
+  /**
+   * 从响应创建错误
+   */
+  static async fromResponse(response) {
+    let body = {};
+    try {
+      body = await response.json();
+    } catch {
+    }
+    const message = body.message || response.statusText || `HTTP ${response.status}`;
+    const code = body.code || response.status;
+    const traceId = body.traceId || body.requestId || response.headers.get("x-request-id") || void 0;
+    return new _DjvApiError(message, code, response.status, traceId, body.details, response);
+  }
+  /**
+   * 转为 JSON（便于日志记录）
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      status: this.status,
+      traceId: this.traceId,
+      details: this.details
+    };
+  }
+};
+var NetworkError = class _NetworkError extends Error {
+  constructor(message, cause) {
+    super(message);
+    /** 标识这是一个网络错误 */
+    this.isNetworkError = true;
+    /** 错误名称 */
+    this.name = "NetworkError";
+    this.originalCause = cause;
+    if (cause && "cause" in Error.prototype) {
+      this.cause = cause;
+    }
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+  /**
+   * 获取原始错误
+   */
+  get cause() {
+    return this.originalCause;
+  }
+  /**
+   * 类型保护：判断是否为 NetworkError（包括子类）
+   */
+  static is(error) {
+    if (error instanceof _NetworkError) return true;
+    if (error == null || typeof error !== "object") return false;
+    return "isNetworkError" in error && error.isNetworkError === true;
+  }
+  /**
+   * 从原始错误创建
+   */
+  static fromError(error) {
+    if (error instanceof _NetworkError) return error;
+    const cause = error instanceof Error ? error : void 0;
+    const message = error instanceof Error ? error.message : String(error);
+    if (cause?.name === "AbortError") {
+      return new AbortError("Request was aborted");
+    }
+    return new _NetworkError(message, cause);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      cause: this.cause?.message
+    };
+  }
+};
+var TimeoutError = class _TimeoutError extends NetworkError {
+  constructor(timeoutMs, url) {
+    super(`Request timeout after ${timeoutMs}ms${url ? `: ${url}` : ""}`);
+    this.timeoutMs = timeoutMs;
+    this.url = url;
+    /** 标识这是一个超时错误 */
+    this.isTimeout = true;
+    this.name = "TimeoutError";
+    Object.setPrototypeOf(this, _TimeoutError.prototype);
+  }
+  /**
+   * 类型保护：判断是否为 TimeoutError
+   */
+  static is(error) {
+    if (error instanceof _TimeoutError) return true;
+    if (error == null || typeof error !== "object") return false;
+    return "isTimeout" in error && error.isTimeout === true;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      timeoutMs: this.timeoutMs,
+      url: this.url
+    };
+  }
+};
+var AbortError = class _AbortError extends NetworkError {
+  constructor(message = "Request was aborted") {
+    super(message);
+    /** 标识这是一个取消错误 */
+    this.isAbort = true;
+    this.name = "AbortError";
+    Object.setPrototypeOf(this, _AbortError.prototype);
+  }
+  /**
+   * 类型保护：判断是否为 AbortError
+   */
+  static is(error) {
+    if (error instanceof _AbortError) return true;
+    if (error == null || typeof error !== "object") return false;
+    return "isAbort" in error && error.isAbort === true;
+  }
+};
+function isRetryableError(error) {
+  if (AbortError.is(error)) return false;
+  if (TimeoutError.is(error) || NetworkError.is(error)) return true;
+  if (DjvApiError.is(error)) {
+    const retryableStatuses = [408, 429, 500, 502, 503, 504];
+    return retryableStatuses.includes(error.status);
+  }
+  return false;
+}
+function getRetryDelay(error, defaultMs = 1e3) {
+  if (DjvApiError.is(error)) {
+    return error.getRetryDelayMs(defaultMs);
+  }
+  return defaultMs;
+}
+
+// src/utils.ts
+function stripTrailingSlash(url) {
+  return url.replace(/\/$/, "");
+}
+function normalizeHeaders(initHeaders) {
+  return new Headers(initHeaders ?? {});
+}
+function mergeHeaders(...headersList) {
+  const result = new Headers();
+  for (const headers of headersList) {
+    if (!headers) continue;
+    const normalized = new Headers(headers);
+    normalized.forEach((value, key) => {
+      result.set(key, value);
+    });
+  }
+  return result;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function calculateBackoffDelay(attempt, baseDelayMs, maxDelayMs, exponential = true) {
+  if (!exponential) return baseDelayMs;
+  const exponentialDelay = baseDelayMs * Math.pow(2, attempt - 1);
+  const jitter = Math.random() * 0.3 * exponentialDelay;
+  const delayWithJitter = exponentialDelay + jitter;
+  return Math.min(delayWithJitter, maxDelayMs);
+}
+function getPlatform() {
+  if (typeof process !== "undefined" && process.versions?.node) {
+    return `node/${process.versions.node}`;
+  }
+  if (typeof Deno !== "undefined") {
+    return `deno/${Deno.version?.deno ?? "unknown"}`;
+  }
+  if (typeof navigator !== "undefined") {
+    const ua = navigator.userAgent;
+    if (ua.includes("Chrome")) return "chrome";
+    if (ua.includes("Firefox")) return "firefox";
+    if (ua.includes("Safari")) return "safari";
+    if (ua.includes("Edge")) return "edge";
+    return "browser";
+  }
+  return "unknown";
+}
+function buildUserAgent(sdkName, sdkVersion) {
+  const platform = getPlatform();
+  return `${sdkName}/${sdkVersion} (${platform})`;
+}
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+async function safeParseJson(response) {
+  try {
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+function cloneResponse(response) {
+  return response.clone();
+}
+
+// src/fetch.ts
+var DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 0,
+  retryDelayMs: 1e3,
+  exponentialBackoff: true,
+  maxDelayMs: 3e4,
+  retryableStatuses: [408, 429, 500, 502, 503, 504],
+  shouldRetry: () => true,
+  onRetry: () => {
+  },
+  respectRetryAfter: true
+  // P1: 默认尊重 Retry-After 头
+};
+function createFetchWithTimeout(fetchImpl, timeoutMs) {
+  return (async (input, init) => {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    const externalSignal = init?.signal;
+    if (externalSignal) {
+      if (externalSignal.aborted) {
+        clearTimeout(timeoutId);
+        throw new AbortError("Request was aborted");
+      }
+      externalSignal.addEventListener("abort", () => {
+        clearTimeout(timeoutId);
+        controller.abort();
+      });
+    }
+    try {
+      const response = await fetchImpl(input, {
+        ...init,
+        signal: controller.signal
+      });
+      return response;
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+        if (externalSignal?.aborted) {
+          throw new AbortError("Request was aborted");
+        }
+        throw new TimeoutError(timeoutMs, url);
+      }
+      throw NetworkError.fromError(error);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  });
+}
+function getRetryDelayFromResponse(response, error, attempt, opts) {
+  if (opts.respectRetryAfter && response) {
+    const retryAfter = response.headers.get("Retry-After");
+    if (retryAfter) {
+      const seconds = parseInt(retryAfter, 10);
+      if (!isNaN(seconds)) {
+        return Math.min(seconds * 1e3, opts.maxDelayMs);
+      }
+      const date = Date.parse(retryAfter);
+      if (!isNaN(date)) {
+        const delayMs = Math.max(0, date - Date.now());
+        return Math.min(delayMs, opts.maxDelayMs);
+      }
+    }
+  }
+  if (DjvApiError.is(error)) {
+    const errorDelay = error.getRetryDelayMs(0);
+    if (errorDelay > 0) {
+      return Math.min(errorDelay, opts.maxDelayMs);
+    }
+  }
+  return calculateBackoffDelay(
+    attempt,
+    opts.retryDelayMs,
+    opts.maxDelayMs,
+    opts.exponentialBackoff
+  );
+}
+function createFetchWithRetry(fetchImpl, options = {}, logger) {
+  const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };
+  return (async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    let lastError;
+    let lastResponse = null;
+    for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+      try {
+        const response = await fetchImpl(input, init);
+        lastResponse = response;
+        if (!response.ok && attempt < opts.maxRetries) {
+          if (opts.retryableStatuses.includes(response.status)) {
+            const error = await DjvApiError.fromResponse(response.clone());
+            if (opts.shouldRetry(error, attempt + 1)) {
+              const delayMs = getRetryDelayFromResponse(
+                response,
+                error,
+                attempt + 1,
+                opts
+              );
+              opts.onRetry(error, attempt + 1, delayMs);
+              logger?.retry?.(url, attempt + 1, error);
+              await delay(delayMs);
+              continue;
+            }
+          }
+        }
+        return response;
+      } catch (error) {
+        lastError = error;
+        if (AbortError.is(error)) {
+          throw error;
+        }
+        if (attempt >= opts.maxRetries) {
+          throw error;
+        }
+        if (!isRetryableError(error) || !opts.shouldRetry(error, attempt + 1)) {
+          throw error;
+        }
+        const delayMs = getRetryDelayFromResponse(
+          lastResponse,
+          error,
+          attempt + 1,
+          opts
+        );
+        opts.onRetry(error, attempt + 1, delayMs);
+        logger?.retry?.(url, attempt + 1, error);
+        await delay(delayMs);
+      }
+    }
+    throw lastError;
+  });
+}
+function createEnhancedFetch(options) {
+  const {
+    fetchApi = fetch,
+    timeoutMs = 3e4,
+    retry,
+    logger
+  } = options;
+  let enhancedFetch = fetchApi;
+  enhancedFetch = createFetchWithTimeout(enhancedFetch, timeoutMs);
+  if (retry && retry.maxRetries && retry.maxRetries > 0) {
+    enhancedFetch = createFetchWithRetry(enhancedFetch, retry, logger);
+  }
+  if (logger) {
+    const wrappedFetch = enhancedFetch;
+    enhancedFetch = (async (input, init) => {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      const startTime = Date.now();
+      logger.request?.(url, init ?? {});
+      try {
+        const response = await wrappedFetch(input, init);
+        const durationMs = Date.now() - startTime;
+        logger.response?.(url, response, durationMs);
+        return response;
+      } catch (error) {
+        logger.error?.(url, error);
+        throw error;
+      }
+    });
+  }
+  return enhancedFetch;
+}
+async function executeRequest(fetchFn, url, init, options) {
+  const finalInit = { ...init };
+  let timeoutController;
+  let timeoutId;
+  if (options?.timeoutMs) {
+    timeoutController = new AbortController();
+    timeoutId = setTimeout(() => timeoutController.abort(), options.timeoutMs);
+    if (options.signal) {
+      options.signal.addEventListener("abort", () => {
+        clearTimeout(timeoutId);
+        timeoutController.abort();
+      });
+    }
+    finalInit.signal = timeoutController.signal;
+  } else if (options?.signal) {
+    finalInit.signal = options.signal;
+  }
+  try {
+    const response = await fetchFn(url, finalInit);
+    if (!response.ok) {
+      throw await DjvApiError.fromResponse(response);
+    }
+    return response;
+  } catch (error) {
+    if (DjvApiError.is(error) || NetworkError.is(error)) {
+      throw error;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      if (options?.signal?.aborted) {
+        throw new AbortError("Request was aborted");
+      }
+      if (options?.timeoutMs) {
+        throw new TimeoutError(options.timeoutMs, url);
+      }
+      throw new AbortError();
+    }
+    throw NetworkError.fromError(error);
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+
+// src/middleware.ts
+function createHeadersMiddleware(opts) {
+  return {
+    async pre(context) {
+      const headers = normalizeHeaders(context.init.headers);
+      if (opts.defaultHeaders) {
+        for (const [key, value] of Object.entries(opts.defaultHeaders)) {
+          headers.set(key, value);
+        }
+      }
+      if (opts.getApiKey) {
+        const apiKey = await opts.getApiKey();
+        if (apiKey) {
+          headers.set("X-Api-Key", apiKey);
+        }
+      }
+      if (opts.getAuthToken) {
+        const token = await opts.getAuthToken();
+        if (token) {
+          headers.set("Authorization", `Bearer ${token}`);
+        }
+      }
+      if (opts.getTraceHeaders) {
+        const traceHeaders = opts.getTraceHeaders();
+        for (const [key, value] of Object.entries(traceHeaders)) {
+          headers.set(key, value);
+        }
+      }
+      if (opts.sdkInfo) {
+        headers.set("X-SDK-Version", `${opts.sdkInfo.name}@${opts.sdkInfo.version}`);
+        headers.set("User-Agent", buildUserAgent(opts.sdkInfo.name, opts.sdkInfo.version));
+      }
+      return {
+        ...context,
+        init: {
+          ...context.init,
+          headers
+        }
+      };
+    }
+  };
+}
+function createLoggingMiddleware(opts) {
+  const requestStartTimes = /* @__PURE__ */ new Map();
+  return {
+    pre(context) {
+      const requestId = `${context.url}-${Date.now()}`;
+      requestStartTimes.set(requestId, Date.now());
+      context.meta = { ...context.meta, requestId };
+      opts.onRequest?.(context.url, context.init);
+      return context;
+    },
+    post(context) {
+      const requestId = context.meta?.requestId;
+      const startTime = requestStartTimes.get(requestId);
+      const durationMs = startTime ? Date.now() - startTime : 0;
+      requestStartTimes.delete(requestId);
+      opts.onResponse?.(context.url, context.response, durationMs);
+    }
+  };
+}
+async function applyMiddlewareChain(middlewares, context) {
+  let currentContext = context;
+  for (const middleware of middlewares) {
+    if (middleware.pre) {
+      currentContext = await middleware.pre(currentContext);
+    }
+  }
+  return currentContext;
+}
+async function applyPostMiddlewareChain(middlewares, context) {
+  for (let i = middlewares.length - 1; i >= 0; i--) {
+    const middleware = middlewares[i];
+    if (middleware.post) {
+      await middleware.post(context);
+    }
+  }
+}
+function createDefaultMiddlewares(opts, sdkInfo) {
+  const middlewares = [];
+  middlewares.push(
+    createHeadersMiddleware({
+      getAuthToken: opts.getAuthToken,
+      getApiKey: opts.getApiKey,
+      getTraceHeaders: opts.getTraceHeaders,
+      defaultHeaders: opts.defaultHeaders,
+      sdkInfo
+    })
+  );
+  if (opts.debug || opts.logger) {
+    middlewares.push(
+      createLoggingMiddleware({
+        onRequest: (url, init) => {
+          if (opts.debug) {
+            console.log(`[API] -> ${init.method ?? "GET"} ${url}`);
+          }
+          opts.logger?.request?.(url, init);
+        },
+        onResponse: (url, response, durationMs) => {
+          if (opts.debug) {
+            console.log(`[API] <- ${response.status} ${url} (${durationMs}ms)`);
+          }
+          opts.logger?.response?.(url, response, durationMs);
+        },
+        onError: (url, error) => {
+          if (opts.debug) {
+            console.error(`[API] !! ${url}`, error);
+          }
+          opts.logger?.error?.(url, error);
+        }
+      })
+    );
+  }
+  return middlewares;
+}
+
+// src/interceptors.ts
+var InterceptorManager = class {
+  constructor(interceptors) {
+    this.requestInterceptors = [];
+    this.responseInterceptors = [];
+    this.errorInterceptors = [];
+    if (interceptors?.request) {
+      this.requestInterceptors.push(...interceptors.request);
+    }
+    if (interceptors?.response) {
+      this.responseInterceptors.push(...interceptors.response);
+    }
+    if (interceptors?.error) {
+      this.errorInterceptors.push(...interceptors.error);
+    }
+  }
+  /**
+   * 添加请求拦截器
+   * @returns 移除拦截器的函数
+   */
+  addRequestInterceptor(interceptor) {
+    this.requestInterceptors.push(interceptor);
+    return () => {
+      const index = this.requestInterceptors.indexOf(interceptor);
+      if (index >= 0) {
+        this.requestInterceptors.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * 添加响应拦截器
+   * @returns 移除拦截器的函数
+   */
+  addResponseInterceptor(interceptor) {
+    this.responseInterceptors.push(interceptor);
+    return () => {
+      const index = this.responseInterceptors.indexOf(interceptor);
+      if (index >= 0) {
+        this.responseInterceptors.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * 添加错误拦截器
+   * @returns 移除拦截器的函数
+   */
+  addErrorInterceptor(interceptor) {
+    this.errorInterceptors.push(interceptor);
+    return () => {
+      const index = this.errorInterceptors.indexOf(interceptor);
+      if (index >= 0) {
+        this.errorInterceptors.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * 执行请求拦截器链
+   */
+  async runRequestInterceptors(context) {
+    let currentContext = context;
+    for (const interceptor of this.requestInterceptors) {
+      currentContext = await interceptor(currentContext);
+    }
+    return currentContext;
+  }
+  /**
+   * 执行响应拦截器链
+   */
+  async runResponseInterceptors(response, context) {
+    let currentResponse = response;
+    for (const interceptor of this.responseInterceptors) {
+      currentResponse = await interceptor(currentResponse, context);
+    }
+    return currentResponse;
+  }
+  /**
+   * 执行错误拦截器链
+   */
+  async runErrorInterceptors(error, context) {
+    let currentError = error;
+    for (const interceptor of this.errorInterceptors) {
+      try {
+        currentError = await interceptor(currentError, context);
+      } catch (e) {
+        currentError = e;
+      }
+    }
+    return currentError;
+  }
+  /**
+   * 清除所有拦截器
+   */
+  clear() {
+    this.requestInterceptors = [];
+    this.responseInterceptors = [];
+    this.errorInterceptors = [];
+  }
+};
+function createTokenRefreshInterceptor(options) {
+  const {
+    refreshToken,
+    shouldRefresh = (response) => response.status === 401,
+    maxRetries = 1
+  } = options;
+  let refreshPromise = null;
+  let retryCount = 0;
+  return async (response, context) => {
+    if (!shouldRefresh(response) || retryCount >= maxRetries) {
+      retryCount = 0;
+      return response;
+    }
+    retryCount++;
+    if (!refreshPromise) {
+      refreshPromise = refreshToken().finally(() => {
+        refreshPromise = null;
+      });
+    }
+    try {
+      const newToken = await refreshPromise;
+      const headers = new Headers(context.init.headers);
+      headers.set("Authorization", `Bearer ${newToken}`);
+      const newResponse = await fetch(context.url, {
+        ...context.init,
+        headers
+      });
+      retryCount = 0;
+      return newResponse;
+    } catch {
+      retryCount = 0;
+      return response;
+    }
+  };
+}
+function createDedupeInterceptor() {
+  const pendingRequests = /* @__PURE__ */ new Map();
+  const getKey = (context) => {
+    return `${context.init.method ?? "GET"}:${context.url}`;
+  };
+  return {
+    interceptor: (context) => {
+      const key = getKey(context);
+      const pending = pendingRequests.get(key);
+      if (pending) {
+        return pending;
+      }
+      return context;
+    },
+    clear: () => {
+      pendingRequests.clear();
+    }
+  };
+}
+function createCacheInterceptor(options) {
+  const {
+    ttlMs = 6e4,
+    shouldCache = (context) => context.init.method === "GET" || !context.init.method,
+    maxSize = 100
+  } = options;
+  const cache = /* @__PURE__ */ new Map();
+  const getKey = (context) => {
+    return `${context.init.method ?? "GET"}:${context.url}`;
+  };
+  const isExpired = (entry) => {
+    return Date.now() - entry.timestamp > ttlMs;
+  };
+  const evictOldest = () => {
+    if (cache.size >= maxSize) {
+      const oldestKey = cache.keys().next().value;
+      if (oldestKey) {
+        cache.delete(oldestKey);
+      }
+    }
+  };
+  return {
+    requestInterceptor: (context) => {
+      if (!shouldCache(context)) {
+        return context;
+      }
+      const key = getKey(context);
+      const entry = cache.get(key);
+      if (entry && !isExpired(entry)) {
+        context.meta = { ...context.meta, fromCache: true, cachedResponse: entry.response.clone() };
+      }
+      return context;
+    },
+    responseInterceptor: (response, context) => {
+      if (!shouldCache(context) || !response.ok) {
+        return response;
+      }
+      const key = getKey(context);
+      evictOldest();
+      cache.set(key, {
+        response: response.clone(),
+        timestamp: Date.now()
+      });
+      return response;
+    },
+    clear: () => {
+      cache.clear();
+    }
+  };
+}
+
+// src/dedupe.ts
+function createRequestDeduper(options = {}) {
+  const {
+    keyGenerator = defaultKeyGenerator,
+    getOnly = true,
+    onDedupe
+  } = options;
+  const inflightRequests = /* @__PURE__ */ new Map();
+  const pendingCounts = /* @__PURE__ */ new Map();
+  function defaultKeyGenerator(url, init) {
+    const method = (init?.method ?? "GET").toUpperCase();
+    if (getOnly && method !== "GET") {
+      return `${method}:${url}:${Date.now()}:${Math.random()}`;
+    }
+    return `${method}:${url}`;
+  }
+  return {
+    /**
+     * 包装 fetch 函数，添加请求去重能力
+     */
+    wrap: (fetchFn) => {
+      return (async (input, init) => {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+        const key = keyGenerator(url, init);
+        const inflight = inflightRequests.get(key);
+        if (inflight) {
+          pendingCounts.set(key, (pendingCounts.get(key) ?? 1) + 1);
+          onDedupe?.(key, pendingCounts.get(key));
+          return inflight.then((response) => response.clone());
+        }
+        const promise = fetchFn(input, init).then((response) => {
+          return response;
+        }).finally(() => {
+          inflightRequests.delete(key);
+          pendingCounts.delete(key);
+        });
+        inflightRequests.set(key, promise);
+        pendingCounts.set(key, 1);
+        return promise;
+      });
+    },
+    /**
+     * 获取当前进行中的请求数量
+     */
+    getPendingCount() {
+      return inflightRequests.size;
+    },
+    /**
+     * 获取所有进行中的请求 key
+     */
+    getPendingKeys() {
+      return Array.from(inflightRequests.keys());
+    },
+    /**
+     * 清除所有进行中的请求记录
+     *
+     * 注意：这不会取消请求，只是清除去重映射
+     */
+    clear() {
+      inflightRequests.clear();
+      pendingCounts.clear();
+    }
+  };
+}
+
+// src/metrics.ts
+function createMetricsCollector(options = {}) {
+  const {
+    maxMetrics = 1e4,
+    ttlMs = 36e5,
+    // 1 小时
+    autoCleanup = true,
+    cleanupIntervalMs = 6e4,
+    // 1 分钟
+    onMetrics
+  } = options;
+  const metricsStore = [];
+  let cleanupTimer = null;
+  if (autoCleanup) {
+    cleanupTimer = setInterval(() => {
+      const now = Date.now();
+      const cutoff = now - ttlMs;
+      let i = 0;
+      while (i < metricsStore.length && metricsStore[i].endTime < cutoff) {
+        i++;
+      }
+      if (i > 0) {
+        metricsStore.splice(0, i);
+      }
+    }, cleanupIntervalMs);
+  }
+  function collect(metrics) {
+    if (metricsStore.length >= maxMetrics) {
+      metricsStore.shift();
+    }
+    metricsStore.push(metrics);
+    onMetrics?.(metrics);
+  }
+  function getMetrics() {
+    return [...metricsStore];
+  }
+  function flush() {
+    const result = [...metricsStore];
+    metricsStore.length = 0;
+    return result;
+  }
+  function summary() {
+    if (metricsStore.length === 0) {
+      return {
+        totalRequests: 0,
+        successCount: 0,
+        failureCount: 0,
+        successRate: 0,
+        avgDurationMs: 0,
+        p50Ms: 0,
+        p90Ms: 0,
+        p95Ms: 0,
+        p99Ms: 0,
+        minMs: 0,
+        maxMs: 0,
+        statusCodeCounts: {},
+        pathCounts: {},
+        timeRange: { start: 0, end: 0 }
+      };
+    }
+    const durations = metricsStore.map((m) => m.durationMs).sort((a, b) => a - b);
+    const successCount = metricsStore.filter((m) => m.success).length;
+    const failureCount = metricsStore.length - successCount;
+    const statusCodeCounts = {};
+    const pathCounts = {};
+    for (const m of metricsStore) {
+      statusCodeCounts[m.status] = (statusCodeCounts[m.status] ?? 0) + 1;
+      pathCounts[m.path] = (pathCounts[m.path] ?? 0) + 1;
+    }
+    const getPercentile = (arr, p) => {
+      const index = Math.floor(arr.length * p);
+      return arr[Math.min(index, arr.length - 1)] ?? 0;
+    };
+    return {
+      totalRequests: metricsStore.length,
+      successCount,
+      failureCount,
+      successRate: successCount / metricsStore.length,
+      avgDurationMs: durations.reduce((a, b) => a + b, 0) / durations.length,
+      p50Ms: getPercentile(durations, 0.5),
+      p90Ms: getPercentile(durations, 0.9),
+      p95Ms: getPercentile(durations, 0.95),
+      p99Ms: getPercentile(durations, 0.99),
+      minMs: durations[0] ?? 0,
+      maxMs: durations[durations.length - 1] ?? 0,
+      statusCodeCounts,
+      pathCounts,
+      timeRange: {
+        start: metricsStore[0]?.startTime ?? 0,
+        end: metricsStore[metricsStore.length - 1]?.endTime ?? 0
+      }
+    };
+  }
+  function getByPath(path) {
+    return metricsStore.filter((m) => m.path === path);
+  }
+  function getByTimeRange(startTime, endTime) {
+    return metricsStore.filter(
+      (m) => m.startTime >= startTime && m.endTime <= endTime
+    );
+  }
+  function clear() {
+    metricsStore.length = 0;
+  }
+  function destroy() {
+    if (cleanupTimer) {
+      clearInterval(cleanupTimer);
+      cleanupTimer = null;
+    }
+    clear();
+  }
+  return {
+    collect,
+    getMetrics,
+    flush,
+    summary,
+    getByPath,
+    getByTimeRange,
+    clear,
+    destroy
+  };
+}
+function generateRequestId() {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+}
+function extractPath(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.pathname;
+  } catch {
+    const match = url.match(/^[^?#]*/);
+    return match?.[0] ?? url;
+  }
+}
+function createMetricsMiddleware(collector) {
+  const requestStarts = /* @__PURE__ */ new Map();
+  return {
+    pre(context) {
+      const requestId = generateRequestId();
+      requestStarts.set(requestId, Date.now());
+      return {
+        ...context,
+        meta: {
+          ...context.meta,
+          metricsRequestId: requestId
+        }
+      };
+    },
+    post(context) {
+      const requestId = context.meta?.metricsRequestId;
+      if (!requestId) return;
+      const startTime = requestStarts.get(requestId);
+      if (!startTime) return;
+      requestStarts.delete(requestId);
+      const endTime = Date.now();
+      const metrics = {
+        requestId,
+        url: context.url,
+        path: extractPath(context.url),
+        method: (context.init.method ?? "GET").toUpperCase(),
+        startTime,
+        endTime,
+        durationMs: endTime - startTime,
+        status: context.response.status,
+        success: context.response.ok,
+        fromCache: context.meta?.fromCache,
+        retryCount: context.meta?.retryCount,
+        traceId: context.response.headers.get("x-request-id") ?? void 0
+      };
+      const contentLength = context.response.headers.get("content-length");
+      if (contentLength) {
+        metrics.responseSize = parseInt(contentLength, 10);
+      }
+      if (context.init.body) {
+        if (typeof context.init.body === "string") {
+          metrics.requestSize = new TextEncoder().encode(context.init.body).length;
+        }
+      }
+      collector.collect(metrics);
+    }
+  };
+}
+
+// src/logger.ts
+function createConsoleLogger(options = {}) {
+  const {
+    prefix = "[DJV-API]",
+    enabled = true,
+    level = "info",
+    timestamp = true,
+    includeBody = false
+  } = options;
+  const levels = ["debug", "info", "warn", "error"];
+  const currentLevelIndex = levels.indexOf(level);
+  const shouldLog = (logLevel) => {
+    return enabled && levels.indexOf(logLevel) >= currentLevelIndex;
+  };
+  const formatTime = () => {
+    if (!timestamp) return "";
+    return `[${(/* @__PURE__ */ new Date()).toISOString()}] `;
+  };
+  const formatMethod = (init) => {
+    return init.method ?? "GET";
+  };
+  return {
+    request: (url, init) => {
+      if (!shouldLog("debug")) return;
+      const method = formatMethod(init);
+      console.log(`${formatTime()}${prefix} -> ${method} ${url}`);
+      if (includeBody && init.body) {
+        try {
+          const body = typeof init.body === "string" ? JSON.parse(init.body) : init.body;
+          console.log(`${prefix} Body:`, body);
+        } catch {
+          console.log(`${prefix} Body: [non-JSON]`);
+        }
+      }
+    },
+    response: (url, response, durationMs) => {
+      if (!shouldLog("info")) return;
+      const status = response.status;
+      const statusEmoji = status >= 200 && status < 300 ? "\u2713" : "\u2717";
+      console.log(
+        `${formatTime()}${prefix} <- ${statusEmoji} ${status} ${url} (${durationMs}ms)`
+      );
+    },
+    error: (url, error) => {
+      if (!shouldLog("error")) return;
+      console.error(`${formatTime()}${prefix} !! ${url}`, error);
+    },
+    retry: (url, attempt, error) => {
+      if (!shouldLog("warn")) return;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.warn(
+        `${formatTime()}${prefix} \u21BB Retry #${attempt} ${url} (${errorMessage})`
+      );
+    }
+  };
+}
+function createSilentLogger() {
+  return {
+    request: () => {
+    },
+    response: () => {
+    },
+    error: () => {
+    },
+    retry: () => {
+    }
+  };
+}
+function createCustomLogger(handlers) {
+  return {
+    request: (url, init) => {
+      handlers.onRequest?.({
+        url,
+        method: init.method ?? "GET",
+        timestamp: Date.now()
+      });
+    },
+    response: (url, response, durationMs) => {
+      handlers.onResponse?.({
+        url,
+        status: response.status,
+        durationMs,
+        timestamp: Date.now()
+      });
+    },
+    error: (url, error) => {
+      handlers.onError?.({
+        url,
+        error,
+        timestamp: Date.now()
+      });
+    },
+    retry: (url, attempt, error) => {
+      handlers.onRetry?.({
+        url,
+        attempt,
+        error,
+        timestamp: Date.now()
+      });
+    }
+  };
+}
+function combineLoggers(...loggers) {
+  return {
+    request: (url, init) => {
+      for (const logger of loggers) {
+        logger.request?.(url, init);
+      }
+    },
+    response: (url, response, durationMs) => {
+      for (const logger of loggers) {
+        logger.response?.(url, response, durationMs);
+      }
+    },
+    error: (url, error) => {
+      for (const logger of loggers) {
+        logger.error?.(url, error);
+      }
+    },
+    retry: (url, attempt, error) => {
+      for (const logger of loggers) {
+        logger.retry?.(url, attempt, error);
+      }
+    }
+  };
+}
+
+// src/configuration.ts
+var Configuration = class _Configuration {
+  constructor(params = {}) {
+    this.basePath = params.basePath ?? "";
+    this.fetchApi = params.fetchApi ?? fetch;
+    this.middleware = params.middleware ?? [];
+    this.credentials = params.credentials;
+    this.interceptors = new InterceptorManager();
+  }
+  /**
+   * 从 ClientOptions 创建 Configuration
+   */
+  static fromClientOptions(opts, sdkInfo) {
+    const config = new _Configuration();
+    config.basePath = stripTrailingSlash(opts.baseUrl);
+    config.credentials = opts.credentials ?? "omit";
+    config.sdkInfo = sdkInfo;
+    config.fetchApi = createEnhancedFetch({
+      fetchApi: opts.fetchApi,
+      timeoutMs: opts.timeoutMs ?? 3e4,
+      retry: opts.retry,
+      logger: opts.logger
+    });
+    config.middleware = [
+      ...createDefaultMiddlewares(opts, sdkInfo),
+      ...opts.middleware ?? []
+    ];
+    if (opts.interceptors) {
+      config.interceptors = new InterceptorManager(opts.interceptors);
+    }
+    return config;
+  }
+};
+function createConfiguration(opts, sdkInfo) {
+  return Configuration.fromClientOptions(opts, sdkInfo);
+}
+
+// src/client-factory.ts
+function createClient(apiClasses, opts, sdkInfo) {
+  const config = Configuration.fromClientOptions(opts, sdkInfo);
+  const apiInstances = {};
+  for (const [name, ApiClass] of Object.entries(apiClasses)) {
+    if (typeof ApiClass === "function" && name.endsWith("Api")) {
+      apiInstances[name] = new ApiClass(config);
+    }
+  }
+  return {
+    config,
+    apis: apiInstances,
+    ...apiInstances
+  };
+}
+function filterApiClasses(exports) {
+  const result = {};
+  for (const [name, value] of Object.entries(exports)) {
+    if (typeof value === "function" && name.endsWith("Api")) {
+      result[name] = value;
+    }
+  }
+  return result;
+}
+export {
+  AbortError,
+  Configuration,
+  DjvApiError,
+  InterceptorManager,
+  NetworkError,
+  SDK_NAME,
+  SDK_VERSION,
+  TimeoutError,
+  applyMiddlewareChain,
+  applyPostMiddlewareChain,
+  buildUserAgent,
+  calculateBackoffDelay,
+  cloneResponse,
+  combineLoggers,
+  createCacheInterceptor,
+  createClient,
+  createConfiguration,
+  createConsoleLogger,
+  createCustomLogger,
+  createDedupeInterceptor,
+  createDefaultMiddlewares,
+  createEnhancedFetch,
+  createFetchWithRetry,
+  createFetchWithTimeout,
+  createHeadersMiddleware,
+  createLoggingMiddleware,
+  createMetricsCollector,
+  createMetricsMiddleware,
+  createRequestDeduper,
+  createSilentLogger,
+  createTokenRefreshInterceptor,
+  delay,
+  executeRequest,
+  filterApiClasses,
+  getPlatform,
+  getRetryDelay,
+  getSdkInfo,
+  isBrowser,
+  isRetryableError,
+  mergeHeaders,
+  normalizeHeaders,
+  safeParseJson,
+  stripTrailingSlash
+};
+//# sourceMappingURL=index.mjs.map