@yh-ui/request 0.1.21

package/dist/cache/memory.d.ts

@@ -0,0 +1,71 @@
+/**
+ * 内存缓存实现
+ * 默认缓存策略
+ */
+export interface CacheOptions {
+    /** 缓存过期时间 (ms)，默认 5 分钟 */
+    staleTime?: number;
+    /** 缓存最大存活时间 (ms)，默认 10 分钟 */
+    cacheTime?: number;
+    /** 是否启用缓存 */
+    enabled?: boolean;
+}
+export interface CacheItem<T> {
+    data: T;
+    expireTime: number;
+    createTime: number;
+    /** 缓存标签 */
+    tags?: string[];
+    /** ETag */
+    etag?: string;
+    /** Last-Modified */
+    lastModified?: string;
+}
+/**
+ * 内存缓存类
+ */
+export declare class MemoryCache {
+    private cache;
+    private cleanupTimer;
+    /**
+     * 获取缓存
+     */
+    get<T>(key: string, _staleTime?: number): T | undefined;
+    /**
+     * 设置缓存
+     */
+    set<T>(key: string, data: T, options?: CacheOptions): void;
+    /**
+     * 删除缓存
+     */
+    delete(key: string): boolean;
+    /**
+     * 清空缓存
+     */
+    clear(): void;
+    /**
+     * 检查缓存是否存在
+     */
+    has(key: string): boolean;
+    /**
+     * 通过标签清除缓存
+     */
+    deleteByTags(_tags: string[]): void;
+    /**
+     * 获取缓存大小
+     */
+    size(): number;
+    /**
+     * 批量获取缓存 keys
+     */
+    keys(): string[];
+    /**
+     * 启动定时清理
+     */
+    startCleanup(interval?: number): void;
+    /**
+     * 停止定时清理
+     */
+    stopCleanup(): void;
+}
+export declare const memoryCache: MemoryCache;

package/dist/cache/memory.mjs

@@ -0,0 +1,103 @@
+export class MemoryCache {
+  cache = /* @__PURE__ */ new Map();
+  cleanupTimer = null;
+  /**
+   * 获取缓存
+   */
+  get(key, _staleTime) {
+    const item = this.cache.get(key);
+    if (!item) return void 0;
+    const now = Date.now();
+    if (item.expireTime && now > item.expireTime) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    return item.data;
+  }
+  /**
+   * 设置缓存
+   */
+  set(key, data, options = {}) {
+    const { staleTime = 5 * 60 * 1e3, cacheTime = 10 * 60 * 1e3 } = options;
+    const now = Date.now();
+    this.cache.set(key, {
+      data,
+      expireTime: now + staleTime,
+      createTime: now
+    });
+    setTimeout(() => {
+      const item = this.cache.get(key);
+      if (item && item.expireTime <= Date.now()) {
+        this.cache.delete(key);
+      }
+    }, cacheTime);
+  }
+  /**
+   * 删除缓存
+   */
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  /**
+   * 清空缓存
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * 检查缓存是否存在
+   */
+  has(key) {
+    const item = this.cache.get(key);
+    if (!item) return false;
+    if (item.expireTime && Date.now() > item.expireTime) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 通过标签清除缓存
+   */
+  deleteByTags(_tags) {
+  }
+  /**
+   * 获取缓存大小
+   */
+  size() {
+    return this.cache.size;
+  }
+  /**
+   * 批量获取缓存 keys
+   */
+  keys() {
+    return Array.from(this.cache.keys());
+  }
+  /**
+   * 启动定时清理
+   */
+  startCleanup(interval = 60 * 1e3) {
+    if (this.cleanupTimer) return;
+    this.cleanupTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [key, item] of this.cache.entries()) {
+        if (item.expireTime && now > item.expireTime) {
+          this.cache.delete(key);
+        }
+      }
+    }, interval);
+  }
+  /**
+   * 停止定时清理
+   */
+  stopCleanup() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+}
+export const memoryCache = new MemoryCache();
+if (typeof window !== "undefined") {
+  memoryCache.startCleanup();
+}

package/dist/graphql.cjs

@@ -0,0 +1,255 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GraphQLClient = exports.GraphQLBuilder = void 0;
+exports.createGraphQLBuilder = createGraphQLBuilder;
+exports.createGraphQLClient = createGraphQLClient;
+exports.createPaginatedQuery = createPaginatedQuery;
+exports.gql = gql;
+exports.parseGraphQLResponse = parseGraphQLResponse;
+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 = [];
+  }
+}
+exports.GraphQLBuilder = GraphQLBuilder;
+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 Promise.resolve().then(() => require("./request.cjs"));
+    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}`;
+  }
+}
+exports.GraphQLClient = GraphQLClient;
+function createGraphQLBuilder() {
+  return new GraphQLBuilder();
+}
+function createGraphQLClient(endpoint, options) {
+  return new GraphQLClient(endpoint, options);
+}
+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;
+}
+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
+  };
+}
+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/graphql.d.ts

@@ -0,0 +1,192 @@
+/**
+ * GraphQL 支持
+ * 提供 GraphQL 查询构建器和请求处理
+ */
+import type { RequestOptions, RequestResponse } from './types';
+/** GraphQL 操作类型 */
+export type GraphQLOperationType = 'query' | 'mutation' | 'subscription';
+/** GraphQL 变量 */
+export type GraphQLVariable = string | number | boolean | null | GraphQLVariable[] | {
+    [key: string]: GraphQLVariable;
+};
+/** GraphQL 请求配置 */
+export interface GraphQLRequestOptions extends RequestOptions {
+    /** GraphQL 操作名称 */
+    operationName?: string;
+    /** 是否返回原始响应 */
+    rawResponse?: boolean;
+}
+/** GraphQL 错误 */
+export interface GraphQLError {
+    message: string;
+    locations?: Array<{
+        line: number;
+        column: number;
+    }>;
+    path?: Array<string | number>;
+    extensions?: Record<string, unknown>;
+}
+/** GraphQL 响应 */
+export interface GraphQLResponse<T = unknown> {
+    data?: T;
+    errors?: GraphQLError[];
+    extensions?: Record<string, unknown>;
+}
+/**
+ * GraphQL 查询构建器
+ *
+ * @example
+ * const query = gql`
+ *   query GetUser($id: ID!) {
+ *     user(id: $id) {
+ *       id
+ *       name
+ *       email
+ *     }
+ *   }
+ * `
+ */
+export declare class GraphQLBuilder {
+    private operationType;
+    private operationName;
+    private variables;
+    private fields;
+    private fragments;
+    private variablesDefinitions;
+    /**
+     * 设置操作类型
+     */
+    operation(type: GraphQLOperationType): this;
+    /**
+     * 设置操作名称
+     */
+    name(name: string): this;
+    /**
+     * 添加变量定义
+     */
+    variable(name: string, type: string, defaultValue?: GraphQLVariable): this;
+    /**
+     * 设置变量
+     */
+    variables_(vars: Record<string, GraphQLVariable>): this;
+    /**
+     * 添加字段
+     */
+    field(field: string): this;
+    /**
+     * 添加多个字段
+     */
+    addFields(fieldsInput: string[]): this;
+    /**
+     * 添加内联片段
+     */
+    inlineFragment(type: string, fieldsInput: string[]): this;
+    /**
+     * 添加片段
+     */
+    fragment(name: string): this;
+    /**
+     * 构建 GraphQL 查询字符串
+     */
+    build(): string;
+    /**
+     * 转换为请求配置
+     */
+    toRequestOptions(options?: GraphQLRequestOptions): GraphQLRequestOptions & {
+        data: {
+            query: string;
+            variables?: Record<string, GraphQLVariable>;
+            operationName?: string;
+        };
+    };
+    /**
+     * 重置构建器
+     */
+    reset(): void;
+}
+/**
+ * GraphQL 客户端
+ * 简化 GraphQL 请求的发送
+ */
+export declare class GraphQLClient {
+    private endpoint;
+    private defaultHeaders;
+    private defaultOptions;
+    /**
+     * 创建 GraphQL 客户端
+     */
+    constructor(endpoint: string, options?: {
+        headers?: Record<string, string>;
+        credentials?: RequestCredentials;
+    });
+    /**
+     * 发送查询
+     */
+    query<T = unknown>(query: string | GraphQLBuilder, variables?: Record<string, GraphQLVariable>, options?: GraphQLRequestOptions): Promise<RequestResponse<GraphQLResponse<T>>>;
+    /**
+     * 发送 mutation
+     */
+    mutate<T = unknown>(mutation: string | GraphQLBuilder, variables?: Record<string, GraphQLVariable>, options?: GraphQLRequestOptions): Promise<RequestResponse<GraphQLResponse<T>>>;
+    /**
+     * 发送原始请求
+     */
+    request<T>(options: GraphQLRequestOptions & {
+        url?: string;
+        data?: unknown;
+    }): Promise<RequestResponse<T>>;
+    /**
+     * 创建查询构建器
+     */
+    createQuery(): GraphQLBuilder;
+    /**
+     * 创建 Mutation 构建器
+     */
+    createMutation(): GraphQLBuilder;
+    /**
+     * 设置默认请求头
+     */
+    setHeader(key: string, value: string): void;
+    /**
+     * 设置认证 Token
+     */
+    setAuthToken(token: string): void;
+}
+/**
+ * 创建 GraphQL 查询构建器
+ */
+export declare function createGraphQLBuilder(): GraphQLBuilder;
+/**
+ * 创建 GraphQL 客户端
+ */
+export declare function createGraphQLClient(endpoint: string, options?: {
+    headers?: Record<string, string>;
+    credentials?: RequestCredentials;
+}): GraphQLClient;
+/**
+ * GraphQL 模板标签函数
+ * 用于更方便地编写 GraphQL 查询
+ *
+ * @example
+ * const query = gql`
+ *   query GetUser($id: ID!) {
+ *     user(id: $id) {
+ *       id
+ *       name
+ *     }
+ *   }
+ * `
+ */
+export declare function gql(strings: TemplateStringsArray, ...values: unknown[]): string;
+/**
+ * 创建分页 GraphQL 查询
+ * @returns 包含 query 字符串和 getVariables 函数的分页查询配置
+ */
+export declare function createPaginatedQuery(queryName: string, itemType: string, pageSize?: number): {
+    query: string;
+    getVariables: (cursor?: string) => Record<string, GraphQLVariable>;
+};
+/**
+ * 解析 GraphQL 响应
+ * @returns 返回 data 字段，类型与 GraphQLResponse 的泛型参数一致
+ */
+export declare function parseGraphQLResponse<T>(response: GraphQLResponse<T>): typeof response.data;