@yh-ui/request 0.1.21

package/dist/graphql.mjs

@@ -0,0 +1,235 @@
+export class GraphQLBuilder {
+  operationType = "query";
+  operationName = "";
+  variables = {};
+  fields = [];
+  fragments = [];
+  variablesDefinitions = [];
+  /**
+   * 设置操作类型
+   */
+  operation(type) {
+    this.operationType = type;
+    return this;
+  }
+  /**
+   * 设置操作名称
+   */
+  name(name) {
+    this.operationName = name;
+    return this;
+  }
+  /**
+   * 添加变量定义
+   */
+  variable(name, type, defaultValue) {
+    const defaultStr = defaultValue !== void 0 ? ` = ${JSON.stringify(defaultValue)}` : "";
+    this.variablesDefinitions.push(`$${name}: ${type}${defaultStr}`);
+    return this;
+  }
+  /**
+   * 设置变量
+   */
+  variables_(vars) {
+    this.variables = vars;
+    return this;
+  }
+  /**
+   * 添加字段
+   */
+  field(field) {
+    this.fields.push(field);
+    return this;
+  }
+  /**
+   * 添加多个字段
+   */
+  addFields(fieldsInput) {
+    this.fields.push(...fieldsInput);
+    return this;
+  }
+  /**
+   * 添加内联片段
+   */
+  inlineFragment(type, fieldsInput) {
+    this.fields.push(`... on ${type} { ${fieldsInput.join(" ")} }`);
+    return this;
+  }
+  /**
+   * 添加片段
+   */
+  fragment(name) {
+    this.fragments.push(`...${name}`);
+    return this;
+  }
+  /**
+   * 构建 GraphQL 查询字符串
+   */
+  build() {
+    const parts = [];
+    const operationHeader = this.operationName ? `${this.operationType} ${this.operationName}` : this.operationType;
+    const variablesStr = this.variablesDefinitions.length > 0 ? `(${this.variablesDefinitions.join(", ")})` : "";
+    const fieldsStr = this.fields.join("\n");
+    parts.push(`${operationHeader}${variablesStr} {
+  ${fieldsStr}
+}`);
+    return parts.join("\n");
+  }
+  /**
+   * 转换为请求配置
+   */
+  toRequestOptions(options = {}) {
+    return {
+      ...options,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      },
+      data: {
+        query: this.build(),
+        variables: Object.keys(this.variables).length > 0 ? this.variables : void 0,
+        operationName: this.operationName || void 0
+      }
+    };
+  }
+  /**
+   * 重置构建器
+   */
+  reset() {
+    this.operationType = "query";
+    this.operationName = "";
+    this.variables = {};
+    this.fields = [];
+    this.fragments = [];
+    this.variablesDefinitions = [];
+  }
+}
+export class GraphQLClient {
+  endpoint;
+  defaultHeaders = {};
+  defaultOptions = {};
+  /**
+   * 创建 GraphQL 客户端
+   */
+  constructor(endpoint, options = {}) {
+    this.endpoint = endpoint;
+    this.defaultHeaders = options.headers || {};
+    this.defaultOptions = {
+      credentials: options.credentials || "same-origin"
+    };
+  }
+  /**
+   * 发送查询
+   */
+  async query(query, variables, options = {}) {
+    const queryStr = typeof query === "string" ? query : query.build();
+    return this.request({
+      ...this.defaultOptions,
+      ...options,
+      method: "POST",
+      url: this.endpoint,
+      headers: {
+        ...this.defaultHeaders,
+        "Content-Type": "application/json",
+        ...options.headers
+      },
+      data: {
+        query: queryStr,
+        variables,
+        operationName: typeof query !== "string" ? query["operationName"] : void 0
+      }
+    });
+  }
+  /**
+   * 发送 mutation
+   */
+  async mutate(mutation, variables, options = {}) {
+    return this.query(mutation, variables, options);
+  }
+  /**
+   * 发送原始请求
+   */
+  async request(options) {
+    const { request } = await import("./request.mjs");
+    return request.request({
+      ...options,
+      url: options.url || this.endpoint
+    });
+  }
+  /**
+   * 创建查询构建器
+   */
+  createQuery() {
+    return new GraphQLBuilder().operation("query");
+  }
+  /**
+   * 创建 Mutation 构建器
+   */
+  createMutation() {
+    return new GraphQLBuilder().operation("mutation");
+  }
+  /**
+   * 设置默认请求头
+   */
+  setHeader(key, value) {
+    this.defaultHeaders[key] = value;
+  }
+  /**
+   * 设置认证 Token
+   */
+  setAuthToken(token) {
+    this.defaultHeaders["Authorization"] = `Bearer ${token}`;
+  }
+}
+export function createGraphQLBuilder() {
+  return new GraphQLBuilder();
+}
+export function createGraphQLClient(endpoint, options) {
+  return new GraphQLClient(endpoint, options);
+}
+export function gql(strings, ...values) {
+  let result = "";
+  strings.forEach((str, i) => {
+    result += str;
+    if (i < values.length) {
+      const value = values[i];
+      if (typeof value === "string") {
+        result += value;
+      } else if (value !== void 0) {
+        result += JSON.stringify(value);
+      }
+    }
+  });
+  return result;
+}
+export function createPaginatedQuery(queryName, itemType, pageSize = 10) {
+  const query = `
+    query ${queryName}($first: Int!, $after: String) {
+      ${queryName}(first: $first, after: $after) {
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+        edges {
+          node {
+            ${itemType}
+          }
+        }
+      }
+    }
+  `;
+  const getVariables = (cursor) => ({
+    first: pageSize,
+    ...cursor ? { after: cursor } : {}
+  });
+  return { query, getVariables };
+}
+export function parseGraphQLResponse(response) {
+  if (response.errors && response.errors.length > 0) {
+    const error = new Error(response.errors.map((e) => e.message).join(", "));
+    error.code = "GRAPHQL_ERROR";
+    throw error;
+  }
+  return response.data;
+}

package/dist/http-cache.cjs

@@ -0,0 +1,248 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HttpCache = void 0;
+exports.createConditionalRequestInterceptor = createConditionalRequestInterceptor;
+exports.createHttpCacheInterceptor = createHttpCacheInterceptor;
+exports.httpCache = void 0;
+exports.isResponseCacheable = isResponseCacheable;
+exports.parseCacheControl = parseCacheControl;
+class HttpCache {
+  cache = /* @__PURE__ */new Map();
+  options;
+  constructor(options = {}) {
+    this.options = {
+      enabled: options.enabled ?? true,
+      etagHeader: options.etagHeader ?? "ETag",
+      lastModifiedHeader: options.lastModifiedHeader ?? "Last-Modified",
+      maxAge: options.maxAge ?? 5 * 60 * 1e3,
+      // 5 分钟
+      staleWhileRevalidate: options.staleWhileRevalidate ?? false,
+      staleTime: options.staleTime ?? 60 * 1e3
+      // 1 分钟
+    };
+  }
+  /**
+   * 从响应中提取缓存信息
+   */
+  extractCacheInfo(response) {
+    const etag = response.headers.get(this.options.etagHeader) || void 0;
+    const lastModified = response.headers.get(this.options.lastModifiedHeader) || void 0;
+    return {
+      etag,
+      lastModified
+    };
+  }
+  /**
+   * 生成缓存键
+   */
+  getCacheKey(config) {
+    return `${config.method}:${config.fullPath || config.url}`;
+  }
+  /**
+   * 获取缓存
+   */
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return void 0;
+    const now = Date.now();
+    if (entry.expireTime && now > entry.expireTime) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    return entry;
+  }
+  /**
+   * 设置缓存
+   */
+  set(key, data, response) {
+    const {
+      etag,
+      lastModified
+    } = this.extractCacheInfo(response);
+    const now = Date.now();
+    const cacheControl = response.headers.get("Cache-Control");
+    let maxAge = this.options.maxAge;
+    if (cacheControl) {
+      const maxAgeMatch = cacheControl.match(/max-age=(\d+)/);
+      if (maxAgeMatch) {
+        maxAge = parseInt(maxAgeMatch[1], 10) * 1e3;
+      }
+      if (cacheControl.includes("no-cache")) {
+        maxAge = 0;
+      }
+    }
+    const entry = {
+      etag,
+      lastModified,
+      data,
+      expireTime: maxAge > 0 ? now + maxAge : now,
+      createTime: now
+    };
+    this.cache.set(key, entry);
+  }
+  /**
+   * 构建条件请求头
+   */
+  buildConditionalHeaders(config) {
+    const key = this.getCacheKey(config);
+    const entry = this.get(key);
+    const headers = {};
+    if (entry) {
+      if (entry.etag) {
+        headers["If-None-Match"] = entry.etag;
+      }
+      if (entry.lastModified) {
+        headers["If-Modified-Since"] = entry.lastModified;
+      }
+    }
+    return headers;
+  }
+  /**
+   * 处理条件响应
+   */
+  handleConditionalResponse(config, response, data) {
+    const key = this.getCacheKey(config);
+    const entry = this.get(key);
+    if (response.status === 304) {
+      if (entry) {
+        return {
+          isModified: false,
+          data: entry.data,
+          entry
+        };
+      }
+    }
+    this.set(key, data, response);
+    return {
+      isModified: true,
+      data
+    };
+  }
+  /**
+   * 获取缓存数据（可能返回过期数据用于 stale-while-revalidate）
+   */
+  getWithFallback(key) {
+    const entry = this.get(key);
+    if (!entry) return void 0;
+    const now = Date.now();
+    const isStale = !!(entry.expireTime && now > entry.expireTime);
+    return {
+      data: entry.data,
+      isStale
+    };
+  }
+  /**
+   * 删除缓存
+   */
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  /**
+   * 清空缓存
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * 获取缓存大小
+   */
+  size() {
+    return this.cache.size;
+  }
+  /**
+   * 清理过期缓存
+   */
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.expireTime && now > entry.expireTime) {
+        this.cache.delete(key);
+      }
+    }
+  }
+}
+exports.HttpCache = HttpCache;
+function createHttpCacheInterceptor(options = {}) {
+  const cache = new HttpCache(options);
+  return {
+    /**
+     * 请求拦截 - 添加条件请求头
+     */
+    onRequest: config => {
+      if (!options.enabled) return config;
+      if (config.method !== "GET") return config;
+      const conditionalHeaders = cache.buildConditionalHeaders(config);
+      return {
+        ...config,
+        headers: {
+          ...config.headers,
+          ...conditionalHeaders
+        }
+      };
+    },
+    /**
+     * 响应拦截 - 处理条件响应
+     */
+    onResponse: response => {
+      if (!options.enabled) return response;
+      if (response.config.method !== "GET") return response;
+      if (response.response.status === 304) {
+        const key = `${response.config.method}:${response.config.fullPath || response.config.url}`;
+        const entry = cache.get(key);
+        if (entry) {
+          return {
+            ...response,
+            data: entry.data
+          };
+        }
+      }
+      cache.set(`${response.config.method}:${response.config.fullPath || response.config.url}`, response.data, response.response);
+      return response;
+    },
+    /**
+     * 获取缓存实例
+     */
+    getCache: () => cache
+  };
+}
+const httpCache = exports.httpCache = new HttpCache();
+function createConditionalRequestInterceptor(options = {}) {
+  return createHttpCacheInterceptor({
+    ...options
+  });
+}
+function parseCacheControl(header) {
+  if (!header) return {
+    noCache: false,
+    noStore: false,
+    mustRevalidate: false,
+    isPublic: false,
+    isPrivate: false
+  };
+  const result = {
+    noCache: false,
+    noStore: false,
+    mustRevalidate: false,
+    isPublic: false,
+    isPrivate: false
+  };
+  const maxAgeMatch = header.match(/max-age=(\d+)/);
+  if (maxAgeMatch) {
+    result.maxAge = parseInt(maxAgeMatch[1], 10);
+  }
+  if (header.includes("no-cache")) result.noCache = true;
+  if (header.includes("no-store")) result.noStore = true;
+  if (header.includes("must-revalidate")) result.mustRevalidate = true;
+  if (header.includes("public")) result.isPublic = true;
+  if (header.includes("private")) result.isPrivate = true;
+  return result;
+}
+function isResponseCacheable(response) {
+  const cacheControl = parseCacheControl(response.headers.get("Cache-Control"));
+  if (cacheControl.noStore) return false;
+  if (cacheControl.isPublic || cacheControl.isPrivate) return true;
+  return response.ok;
+}

package/dist/http-cache.d.ts

@@ -0,0 +1,156 @@
+/**
+ * HTTP 缓存协议支持
+ * 支持 ETag、Last-Modified、Cache-Control 等 HTTP 缓存机制
+ */
+import type { InternalRequestOptions, RequestResponse } from './types';
+/** HTTP 缓存控制选项 */
+export interface HttpCacheOptions {
+    /** 启用条件请求 */
+    enabled?: boolean;
+    /** ETag 头名称 */
+    etagHeader?: string;
+    /** Last-Modified 头名称 */
+    lastModifiedHeader?: string;
+    /** 缓存过期时间 (ms) */
+    maxAge?: number;
+    /** 是否启用 stale-while-revalidate */
+    staleWhileRevalidate?: boolean;
+    /** 备用缓存时间 (当使用 stale-while-revalidate 时) */
+    staleTime?: number;
+}
+/** 缓存条目 */
+export interface HttpCacheEntry {
+    /** ETag */
+    etag?: string;
+    /** Last-Modified */
+    lastModified?: string;
+    /** 缓存数据 */
+    data: unknown;
+    /** 过期时间 */
+    expireTime: number;
+    /** 创建时间 */
+    createTime: number;
+    /** 响应头 */
+    headers?: Record<string, string>;
+}
+/** 条件请求响应 */
+export interface ConditionalResponse {
+    /** 是否有修改 */
+    isModified: boolean;
+    /** 响应数据 */
+    data?: unknown;
+    /** 缓存条目 */
+    entry?: HttpCacheEntry;
+}
+/**
+ * HTTP 缓存管理器
+ * 支持 HTTP 条件请求 (ETag、Last-Modified)
+ */
+export declare class HttpCache {
+    private cache;
+    private options;
+    constructor(options?: HttpCacheOptions);
+    /**
+     * 从响应中提取缓存信息
+     */
+    extractCacheInfo(response: Response): {
+        etag?: string;
+        lastModified?: string;
+    };
+    /**
+     * 生成缓存键
+     */
+    private getCacheKey;
+    /**
+     * 获取缓存
+     */
+    get(key: string): HttpCacheEntry | undefined;
+    /**
+     * 设置缓存
+     */
+    set(key: string, data: unknown, response: Response): void;
+    /**
+     * 构建条件请求头
+     */
+    buildConditionalHeaders(config: InternalRequestOptions): Record<string, string>;
+    /**
+     * 处理条件响应
+     */
+    handleConditionalResponse(config: InternalRequestOptions, response: Response, data: unknown): ConditionalResponse;
+    /**
+     * 获取缓存数据（可能返回过期数据用于 stale-while-revalidate）
+     */
+    getWithFallback(key: string): {
+        data: unknown;
+        isStale: boolean;
+    } | undefined;
+    /**
+     * 删除缓存
+     */
+    delete(key: string): boolean;
+    /**
+     * 清空缓存
+     */
+    clear(): void;
+    /**
+     * 获取缓存大小
+     */
+    size(): number;
+    /**
+     * 清理过期缓存
+     */
+    cleanup(): void;
+}
+/**
+ * 创建 HTTP 缓存拦截器
+ */
+export declare function createHttpCacheInterceptor(options?: HttpCacheOptions): {
+    /**
+     * 请求拦截 - 添加条件请求头
+     */
+    onRequest: (config: InternalRequestOptions) => InternalRequestOptions;
+    /**
+     * 响应拦截 - 处理条件响应
+     */
+    onResponse: <T>(response: RequestResponse<T>) => RequestResponse<T>;
+    /**
+     * 获取缓存实例
+     */
+    getCache: () => HttpCache;
+};
+/**
+ * 全局 HTTP 缓存实例
+ */
+export declare const httpCache: HttpCache;
+/**
+ * 创建条件请求拦截器（使用全局缓存）
+ */
+export declare function createConditionalRequestInterceptor(options?: HttpCacheOptions): {
+    /**
+     * 请求拦截 - 添加条件请求头
+     */
+    onRequest: (config: InternalRequestOptions) => InternalRequestOptions;
+    /**
+     * 响应拦截 - 处理条件响应
+     */
+    onResponse: <T>(response: RequestResponse<T>) => RequestResponse<T>;
+    /**
+     * 获取缓存实例
+     */
+    getCache: () => HttpCache;
+};
+/**
+ * 解析 Cache-Control 头
+ */
+export declare function parseCacheControl(header: string | null): {
+    maxAge?: number;
+    noCache: boolean;
+    noStore: boolean;
+    mustRevalidate: boolean;
+    isPublic: boolean;
+    isPrivate: boolean;
+};
+/**
+ * 判断响应是否可以缓存
+ */
+export declare function isResponseCacheable(response: Response): boolean;