From 6a81b7bb13315ffff07ac27ce5796d5ccea58918 Mon Sep 17 00:00:00 2001 From: tobegold574 <2386340403@qq.com> Date: Mon, 10 Nov 2025 20:20:25 +0800 Subject: [PATCH] =?UTF-8?q?feat(image):=20=E6=96=B0=E5=BB=BA=20knowai-core?= =?UTF-8?q?:1.0.0=20=E9=95=9C=E5=83=8F=E5=B9=B6=E5=AE=8C=E6=88=90=E6=8E=A8?= =?UTF-8?q?=E9=80=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 搭建 api、auth、utils 等逻辑模块 - 通过 tsc、eslint、vitest 测试验证 BREAKING CHANGE: 新镜像分支 --- .drone.yml | 125 ++ .gitignore | 13 + FOLDER_STRUCTURE.md | 142 ++ README.md | 107 ++ api/README.md | 57 + api/client.ts | 279 +++ api/errors.ts | 46 + api/factory.ts | 40 + api/index.ts | 19 + api/modules/chat.ts | 48 + api/modules/index.ts | 14 + api/modules/model.ts | 29 + api/modules/post.ts | 65 + api/modules/user.ts | 51 + api/types.d.ts | 119 ++ auth/README.md | 217 +++ auth/auth-service.ts | 170 ++ auth/errors.ts | 67 + auth/event-manager.ts | 65 + auth/index.ts | 22 + auth/session-manager.ts | 92 + auth/storage-adapter.ts | 55 + auth/types.d.ts | 85 + eslint.config.js | 137 ++ index.ts | 11 + package.json | 34 + pnpm-lock.yaml | 2338 ++++++++++++++++++++++++++ test/README.md | 132 ++ test/auth/session-manager.test.ts | 149 ++ test/mocks/data-factory.ts | 702 ++++++++ test/mocks/http-client.ts | 74 + test/mocks/index.ts | 7 + test/mocks/storage.ts | 23 + test/setup.ts | 53 + test/unit/api/client.test.ts | 464 +++++ test/unit/api/modules/chat.test.ts | 345 ++++ test/unit/api/modules/model.test.ts | 239 +++ test/unit/api/modules/post.test.ts | 408 +++++ test/unit/api/modules/user.test.ts | 334 ++++ test/unit/auth/auth-service.test.ts | 379 +++++ test/unit/auth/event-manager.test.ts | 174 ++ test/unit/utils/data.test.ts | 482 ++++++ test/unit/utils/date.test.ts | 157 ++ test/unit/utils/string.test.ts | 183 ++ test/unit/utils/validation.test.ts | 224 +++ test/utils/test-helpers.ts | 159 ++ tsconfig.json | 56 + types/README.md | 10 + types/chat/api.d.ts | 96 ++ types/chat/base.d.ts | 45 + types/chat/enum.d.ts | 19 + types/chat/index.d.ts | 3 + types/index.d.ts | 5 + types/model/api.d.ts | 160 ++ types/model/base.d.ts | 31 + types/model/enum.d.ts | 6 + types/model/index.d.ts | 4 + types/post/api.d.ts | 124 ++ types/post/base.d.ts | 41 + types/post/enum.d.ts | 28 + types/post/index.d.ts | 4 + types/user/base.d.ts | 52 + types/user/enum.d.ts | 8 + types/user/index.d.ts | 4 + types/user/profile.d.ts | 36 + types/user/search.d.ts | 12 + utils/README.md | 35 + utils/data.ts | 272 +++ utils/date.ts | 83 + utils/index.ts | 5 + utils/string.ts | 90 + utils/validation.ts | 110 ++ vitest.config.ts | 37 + 73 files changed, 10511 insertions(+) create mode 100644 .drone.yml create mode 100644 .gitignore create mode 100644 FOLDER_STRUCTURE.md create mode 100644 README.md create mode 100644 api/README.md create mode 100644 api/client.ts create mode 100644 api/errors.ts create mode 100644 api/factory.ts create mode 100644 api/index.ts create mode 100644 api/modules/chat.ts create mode 100644 api/modules/index.ts create mode 100644 api/modules/model.ts create mode 100644 api/modules/post.ts create mode 100644 api/modules/user.ts create mode 100644 api/types.d.ts create mode 100644 auth/README.md create mode 100644 auth/auth-service.ts create mode 100644 auth/errors.ts create mode 100644 auth/event-manager.ts create mode 100644 auth/index.ts create mode 100644 auth/session-manager.ts create mode 100644 auth/storage-adapter.ts create mode 100644 auth/types.d.ts create mode 100644 eslint.config.js create mode 100644 index.ts create mode 100644 package.json create mode 100644 pnpm-lock.yaml create mode 100644 test/README.md create mode 100644 test/auth/session-manager.test.ts create mode 100644 test/mocks/data-factory.ts create mode 100644 test/mocks/http-client.ts create mode 100644 test/mocks/index.ts create mode 100644 test/mocks/storage.ts create mode 100644 test/setup.ts create mode 100644 test/unit/api/client.test.ts create mode 100644 test/unit/api/modules/chat.test.ts create mode 100644 test/unit/api/modules/model.test.ts create mode 100644 test/unit/api/modules/post.test.ts create mode 100644 test/unit/api/modules/user.test.ts create mode 100644 test/unit/auth/auth-service.test.ts create mode 100644 test/unit/auth/event-manager.test.ts create mode 100644 test/unit/utils/data.test.ts create mode 100644 test/unit/utils/date.test.ts create mode 100644 test/unit/utils/string.test.ts create mode 100644 test/unit/utils/validation.test.ts create mode 100644 test/utils/test-helpers.ts create mode 100644 tsconfig.json create mode 100644 types/README.md create mode 100644 types/chat/api.d.ts create mode 100644 types/chat/base.d.ts create mode 100644 types/chat/enum.d.ts create mode 100644 types/chat/index.d.ts create mode 100644 types/index.d.ts create mode 100644 types/model/api.d.ts create mode 100644 types/model/base.d.ts create mode 100644 types/model/enum.d.ts create mode 100644 types/model/index.d.ts create mode 100644 types/post/api.d.ts create mode 100644 types/post/base.d.ts create mode 100644 types/post/enum.d.ts create mode 100644 types/post/index.d.ts create mode 100644 types/user/base.d.ts create mode 100644 types/user/enum.d.ts create mode 100644 types/user/index.d.ts create mode 100644 types/user/profile.d.ts create mode 100644 types/user/search.d.ts create mode 100644 utils/README.md create mode 100644 utils/data.ts create mode 100644 utils/date.ts create mode 100644 utils/index.ts create mode 100644 utils/string.ts create mode 100644 utils/validation.ts create mode 100644 vitest.config.ts diff --git a/.drone.yml b/.drone.yml new file mode 100644 index 0000000..845b98b --- /dev/null +++ b/.drone.yml @@ -0,0 +1,125 @@ +kind: pipeline +type: kubernetes +name: verify-knowai-core + +trigger: + branch: + - knowai-core + event: + - push + +volumes: + - name: pnpm-store-cache + emptyDir: {} + - name: repo-volume + emptyDir: {} + +clone: + disable: true + +steps: + # 0️⃣ 克隆代码 + - name: clone + image: alpine/git:latest + environment: + CA_CRT: + from_secret: ca-crt + commands: + - apk add --no-cache ca-certificates + - echo "$CA_CRT" > /etc/ssl/certs/ca.crt + - update-ca-certificates + - git clone https://gitea.local.knowai/tobegold574/knowai.git /drone/src + - cd /drone/src + - git checkout ${DRONE_BRANCH} + - echo "✅ 当前分支：$(git rev-parse --abbrev-ref HEAD)" + volumeMounts: + - name: repo-volume + mountPath: /drone/src + + # 1️⃣ 准备环境 + - name: prepare-environment + image: gitea.local.knowai/tobegold574/knowai-base:1.0.0 + commands: + - cd /drone/src/frontend/knowai-core + - echo "🚀 验证 Node.js 环境..." + - node --version + - pnpm --version + - echo "🔍 检查 pnpm 存储路径..." + - pnpm store path + - echo "🔍 检查项目结构..." + - ls -la + volumeMounts: + - name: repo-volume + mountPath: /drone/src + + # 2️⃣ 安装依赖 + - name: install-dependencies + image: gitea.local.knowai/tobegold574/knowai-base:1.0.0 + commands: + - cd /drone/src/frontend/knowai-core + - echo "📦 安装项目依赖..." + - pnpm install --registry=https://registry.npmmirror.com --no-frozen-lockfile + - echo "✅ 依赖安装完成" + volumeMounts: + - name: repo-volume + mountPath: /drone/src + - name: pnpm_store_cache + mountPath: /pnpm-global/store + + # 3️⃣ 类型检查 + - name: type-check + image: gitea.local.knowai/tobegold574/knowai-base:1.0.0 + commands: + - cd /drone/src/frontend/knowai-core + - echo "🔍 执行 TypeScript 类型检查..." + - pnpm run type-check + - echo "✅ 类型检查通过" + volumeMounts: + - name: repo-volume + mountPath: /drone/src + - name: pnpm_store_cache + mountPath: /pnpm-global/store + + # 4️⃣ 代码检查 + - name: lint + image: gitea.local.knowai/tobegold574/knowai-base:1.0.0 + commands: + - cd /drone/src/frontend/knowai-core + - echo "🔍 执行 ESLint 代码检查..." + - pnpm run lint + - echo "✅ 代码检查通过" + volumeMounts: + - name: repo-volume + mountPath: /drone/src + - name: pnpm_store_cache + mountPath: /pnpm-global/store + + # 5️⃣ 运行测试 + - name: test + image: gitea.local.knowai/tobegold574/knowai-base:1.0.0 + commands: + - cd /drone/src/frontend/knowai-core + - echo "🧪 运行单元测试..." + - pnpm run test + - echo "✅ 测试通过" + volumeMounts: + - name: repo-volume + mountPath: /drone/src + - name: pnpm_store_cache + mountPath: /pnpm-global/store + + # 6️⃣ 构建验证 + - name: build + image: gitea.local.knowai/tobegold574/knowai-base:1.0.0 + commands: + - cd /drone/src/frontend/knowai-core + - echo "🔨 验证构建过程..." + - pnpm run build + - echo "📁 检查构建产物..." + - ls -la dist/ + - echo "✅ 构建验证通过" + volumeMounts: + - name: repo-volume + mountPath: /drone/src + - name: pnpm_store_cache + mountPath: /pnpm-global/store diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..250ec87 --- /dev/null +++ b/.gitignore @@ -0,0 +1,13 @@ +# 依赖相关 +node_modules +.pnpm-store/ + +# 测试与打包 +coverage/ + +# 编辑器 +.vscode/* + +# docker构建 +Dockerfile +.dockerignore diff --git a/FOLDER_STRUCTURE.md b/FOLDER_STRUCTURE.md new file mode 100644 index 0000000..fb42726 --- /dev/null +++ b/FOLDER_STRUCTURE.md @@ -0,0 +1,142 @@ + . + ├─ Dockerfile + ├─ FOLDER_STRUCTURE.md + ├─ README.md + ├─ api + │   ├─ README.md + │   ├─ client.ts + │   ├─ errors.ts + │   ├─ factory.ts + │   ├─ index.ts + │   ├─ modules + │   │   ├─ chat.ts + │   │   ├─ index.ts + │   │   ├─ model.ts + │   │   ├─ post.ts + │   │   └─ user.ts + │   └─ types.d.ts + ├─ auth + │   ├─ README.md + │   ├─ auth-service.ts + │   ├─ errors.ts + │   ├─ event-manager.ts + │   ├─ index.ts + │   ├─ session-manager.ts + │   ├─ storage-adapter.ts + │   └─ types.d.ts + ├─ coverage + │   ├─ api + │   │   ├─ client.ts.html + │   │   ├─ errors.ts.html + │   │   ├─ index.html + │   │   └─ modules + │   │   ├─ chat.ts.html + │   │   ├─ index.html + │   │   ├─ model.ts.html + │   │   ├─ post.ts.html + │   │   └─ user.ts.html + │   ├─ auth + │   │   ├─ auth-service.ts.html + │   │   ├─ errors.ts.html + │   │   ├─ event-manager.ts.html + │   │   ├─ index.html + │   │   ├─ session-manager.ts.html + │   │   └─ storage-adapter.ts.html + │   ├─ base.css + │   ├─ block-navigation.js + │   ├─ coverage-final.json + │   ├─ favicon.png + │   ├─ index.html + │   ├─ prettify.css + │   ├─ prettify.js + │   ├─ sort-arrow-sprite.png + │   ├─ sorter.js + │   └─ utils + │   ├─ data.ts.html + │   ├─ date.ts.html + │   ├─ index.html + │   ├─ string.ts.html + │   └─ validation.ts.html + ├─ eslint.config.js + ├─ index.ts + ├─ node_modules + │   ├─ @eslint + │   │   └─ js + │   ├─ @types + │   │   ├─ lodash + │   │   └─ node + │   ├─ @typescript-eslint + │   │   ├─ eslint-plugin + │   │   └─ parser + │   ├─ @vitest + │   │   └─ coverage-v8 + │   ├─ axios + │   ├─ eslint + │   ├─ typescript + │   └─ vitest + ├─ package.json + ├─ pnpm-lock.yaml + ├─ test + │   ├─ README.md + │   ├─ auth + │   │   └─ session-manager.test.ts + │   ├─ integration + │   ├─ mocks + │   │   ├─ data-factory.ts + │   │   ├─ http-client.ts + │   │   ├─ index.ts + │   │   └─ storage.ts + │   ├─ setup.ts + │   ├─ unit + │   │   ├─ api + │   │   │   ├─ client.test.ts + │   │   │   └─ modules + │   │   │   ├─ chat.test.ts + │   │   │   ├─ model.test.ts + │   │   │   ├─ post.test.ts + │   │   │   └─ user.test.ts + │   │   ├─ auth + │   │   │   ├─ auth-service.test.ts + │   │   │   └─ event-manager.test.ts + │   │   └─ utils + │   │   ├─ data.test.ts + │   │   ├─ date.test.ts + │   │   ├─ string.test.ts + │   │   └─ validation.test.ts + │   └─ utils + │   └─ test-helpers.ts + ├─ tsconfig.json + ├─ types + │   ├─ README.md + │   ├─ chat + │   │   ├─ api.d.ts + │   │   ├─ base.d.ts + │   │   ├─ enum.d.ts + │   │   └─ index.d.ts + │   ├─ index.d.ts + │   ├─ model + │   │   ├─ api.d.ts + │   │   ├─ base.d.ts + │   │   ├─ enum.d.ts + │   │   └─ index.d.ts + │   ├─ post + │   │   ├─ api.d.ts + │   │   ├─ base.d.ts + │   │   ├─ enum.d.ts + │   │   └─ index.d.ts + │   └─ user + │   ├─ base.d.ts + │   ├─ enum.d.ts + │   ├─ index.d.ts + │   ├─ profile.d.ts + │   └─ search.d.ts + ├─ utils + │   ├─ README.md + │   ├─ data.ts + │   ├─ date.ts + │   ├─ index.ts + │   ├─ string.ts + │   └─ validation.ts + └─ vitest.config.ts + + 39 directories, 100 files diff --git a/README.md b/README.md new file mode 100644 index 0000000..648c207 --- /dev/null +++ b/README.md @@ -0,0 +1,107 @@ +# KnowAI Core + +## 概述 + +KnowAI Core 是前端核心库，提供业务逻辑、数据处理和认证功能，严格遵循分层架构原则，专注于核心功能实现，不包含UI交互逻辑。 + +## 架构设计 + +### 分层架构 + +- **Core层**：提供核心业务逻辑、数据处理和状态管理 + +### 事件驱动设计 + +为了实现层间解耦，认证模块采用事件驱动架构： +- Core层定义事件类型和事件触发机制 +- 上层应用注册事件监听器，处理UI交互逻辑 +- 避免Core层直接依赖UI层或路由系统 + +## 核心模块 + +### API 模块 + +API模块负责处理所有与后端通信相关的逻辑，提供统一的HTTP请求接口和模块化的API服务： + +#### 核心功能 +- **请求工厂**：使用工厂模式创建API实例，统一配置请求参数 +- **拦截器系统**：支持请求/响应拦截器，实现统一的错误处理、日志记录和认证 +- **模块化API服务**：按功能域划分API服务，如用户API、内容API等 +- **响应标准化**：统一处理API响应格式，提供一致的错误处理机制 + +#### 架构特点 +- 基于axios构建，支持请求/响应转换 +- 自动处理认证令牌附加 +- 统一的错误处理和重试机制 +- 支持请求取消和超时控制 + +### Auth 模块 + +Auth模块提供完整的认证功能，管理用户身份验证和授权状态： + +#### 核心功能 +- **令牌管理**：管理访问令牌和刷新令牌，实现自动令牌刷新 +- **认证状态管理**：维护用户登录状态，提供状态查询接口 +- **事件驱动通知**：通过事件系统通知认证状态变化，如登录、登出、令牌过期等 +- **权限控制**：提供基于角色的权限检查功能 + +#### 架构特点 +- 事件驱动的状态通知机制，实现与UI层的解耦 +- 自动处理令牌过期和刷新流程 +- 支持多种认证方式（令牌、OAuth等） +- 安全的令牌存储机制 + +### Utils 模块 + +Utils模块提供常用的工具函数，支持数据处理和业务逻辑实现： + +#### 核心功能 +- **数据处理工具**：提供数据转换、过滤、排序等常用数据处理函数 +- **字符串处理工具**：提供字符串格式化、验证、转换等工具函数 +- **日期处理工具**：提供日期格式化、计算、比较等日期相关函数 +- **验证工具**：提供表单验证、数据格式验证等验证函数 + +#### 架构特点 +- 纯函数设计，无副作用，易于测试 +- 函数式编程风格，支持链式调用 +- 完整的TypeScript类型支持 +- 模块化设计，按需导入 + +### Types 模块 + +Types模块提供TypeScript类型定义，确保整个应用的类型安全： + +#### 核心功能 +- **API相关类型**：定义请求参数、响应数据等API相关类型 +- **业务实体类型**：定义业务领域中的实体类型，如用户、内容等 +- **通用类型定义**：提供通用的工具类型和类型别名 +- **事件类型定义**：定义事件系统中使用的事件类型 + +#### 架构特点 +- 严格的类型定义，提供编译时类型检查 +- 支持泛型和高级类型特性 +- 类型文档完善，提高开发体验 +- 与业务逻辑紧密关联，确保类型一致性 + +## 目录结构 + +``` +knowai-core/ +├── api/ # API模块 +├── auth/ # 认证模块 +├── utils/ # 工具函数模块 +├── types/ # 类型定义模块 +├── test/ # 测试文件 +├── index.ts # 主入口文件 +├── package.json # 项目配置 +├── tsconfig.json # TypeScript配置 +└── vitest.config.ts # 测试配置 +``` + +## 设计原则 + +1. **关注点分离**：业务逻辑与UI逻辑分离，Core层专注于核心功能实现 +2. **事件驱动**：通过事件系统实现层间解耦，降低模块间耦合度 +3. **类型安全**：充分利用TypeScript类型系统，提供编译时类型检查 +4. **模块化**：按功能域组织，按需导入，提高代码复用性 +5. **可测试性**：纯函数和依赖注入提高可测试性，确保代码质量 diff --git a/api/README.md b/api/README.md new file mode 100644 index 0000000..ffea02b --- /dev/null +++ b/api/README.md @@ -0,0 +1,57 @@ +# API 模块 + +## 概述 + +API 模块提供统一的HTTP客户端和API请求处理功能，支持模块化的API端点管理。 + +## 核心组件 + +1. **API 客户端 (client.ts)** + - 基于Axios的HTTP客户端 + - 提供统一的请求和响应处理 + - 支持请求拦截器和响应拦截器 + +2. **API 工厂 (factory.ts)** + - 创建API客户端实例 + - 配置默认请求选项 + - 提供单例模式确保全局一致性 + +3. **API 模块 (modules/)** + - 按功能模块组织API端点 + - 提供类型安全的API方法 + - 包含用户、聊天等业务模块 + +4. **类型定义 (types.d.ts)** + - 定义API相关的接口和类型 + - 包含请求配置和响应格式 + +5. **错误处理 (errors.ts)** + - 定义API相关的错误类 + - 提供错误处理和转换功能 + +## 使用方法 + +```typescript +import { createApiClient } from './api'; + +// 创建API客户端 +const apiClient = createApiClient({ + baseURL: 'https://api.example.com', + timeout: 10000, +}); + +// 使用API模块 +import { userApi } from './api/modules/user'; + +// 获取用户信息 +const user = await userApi.getUser('userId'); + +// 更新用户信息 +await userApi.updateUser('userId', { name: 'New Name' }); +``` + +## 设计模式 + +- **工厂模式**：创建API客户端实例 +- **单例模式**：确保API客户端全局唯一 +- **模块化模式**：按功能组织API端点 \ No newline at end of file diff --git a/api/client.ts b/api/client.ts new file mode 100644 index 0000000..06338d6 --- /dev/null +++ b/api/client.ts @@ -0,0 +1,279 @@ +import axios from 'axios'; +import type { ApiClient } from './types'; +import type { AxiosError, AxiosResponse, AxiosRequestConfig, InternalAxiosRequestConfig } from 'axios'; +import { ApiError } from './errors'; // 直接导入ApiError + +// 创建API客户端实例的工厂函数 +const createApiClientInstance = (config?: Partial): ApiClient => { + // 创建axios实例 + const instance = axios.create({ + baseURL: '/api', // Core层使用默认值，具体配置由Runtime层注入 + timeout: 10000, + headers: { + 'Content-Type': 'application/json' + }, + withCredentials: true, // 允许跨域携带cookie + ...config // 应用传入的配置 + }); + + // 请求拦截器数组 + const requestInterceptors: Array = []; + + // 响应拦截器数组 + const responseInterceptors: Array = []; + + // 添加请求拦截器 + const addRequestInterceptor = ( + onFulfilled?: (_config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig | Promise, + onRejected?: (_error: unknown) => unknown + ): number => { + const handler = instance.interceptors.request.use(onFulfilled, onRejected); + requestInterceptors.push(handler); + return handler; + }; + + // 添加响应拦截器 + const addResponseInterceptor = ( + onFulfilled?: (_response: AxiosResponse) => AxiosResponse | Promise, + onRejected?: (_error: unknown) => unknown + ): number => { + const handler = instance.interceptors.response.use(onFulfilled, onRejected); + responseInterceptors.push(handler); + return handler; + }; + + // 移除请求拦截器 + const removeRequestInterceptor = (handler: number): void => { + const index = requestInterceptors.indexOf(handler); + if (index !== -1) { + instance.interceptors.request.eject(handler); + requestInterceptors.splice(index, 1); + } + }; + + // 移除响应拦截器 + const removeResponseInterceptor = (handler: number): void => { + const index = responseInterceptors.indexOf(handler); + if (index !== -1) { + instance.interceptors.response.eject(handler); + responseInterceptors.splice(index, 1); + } + }; + + // 设置默认配置 + const setDefaults = (_config: Partial): void => { + Object.assign(instance.defaults, _config); + }; + + // 更新基础URL - 专门用于Runtime层配置 + const setBaseURL = (baseURL: string): void => { + instance.defaults.baseURL = baseURL; + }; + + // 创建新实例 - 用于跨域请求等特殊场景 + const createInstance = (config?: Partial): ApiClient => { + // 创建新的axios实例 + const newInstance = axios.create({ + ...instance.defaults, + ...config + }); + + // 为新实例创建拦截器数组 + const newRequestInterceptors: Array = []; + const newResponseInterceptors: Array = []; + + // 复制拦截器 + requestInterceptors.forEach(handler => { + // 由于AxiosInterceptorManager类型定义中没有handlers属性， + // 我们使用类型断言来访问内部属性 + type RequestHandlerType = { + id: number; + fulfilled: (_config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig; + rejected: (_error: unknown) => unknown; + }; + + type RequestManagerType = { + handlers?: Array; + }; + + const requestManager = instance.interceptors.request as unknown as RequestManagerType; + const originalInterceptor = requestManager.handlers?.find((h: RequestHandlerType) => h.id === handler); + if (originalInterceptor) { + const newHandler = newInstance.interceptors.request.use( + originalInterceptor.fulfilled, + originalInterceptor.rejected + ); + newRequestInterceptors.push(newHandler); + } + }); + + responseInterceptors.forEach(handler => { + // 由于AxiosInterceptorManager类型定义中没有handlers属性， + // 我们使用类型断言来访问内部属性 + type ResponseHandlerType = { + id: number; + fulfilled: (_response: AxiosResponse) => AxiosResponse; + rejected: (_error: AxiosError) => unknown; + }; + + type ResponseManagerType = { + handlers?: Array; + }; + + const responseManager = instance.interceptors.response as unknown as ResponseManagerType; + const originalInterceptor = responseManager.handlers?.find((h: ResponseHandlerType) => h.id === handler); + if (originalInterceptor) { + const newHandler = newInstance.interceptors.response.use( + originalInterceptor.fulfilled, + originalInterceptor.rejected + ); + newResponseInterceptors.push(newHandler); + } + }); + + // 返回一个符合ApiClient接口的对象 + return { + request: async (config: AxiosRequestConfig): Promise => { + try { + const response = await newInstance.request(config); + return response.data; + } catch (error) { + // 直接使用ApiError.fromAxiosError静态方法处理错误 + return Promise.reject(ApiError.fromAxiosError(error as AxiosError)); + } + }, + get: (url: string, config?: AxiosRequestConfig): Promise => { + return newInstance.request({ ...config, method: 'GET', url }).then((res: AxiosResponse) => res.data); + }, + post: (url: string, data?: unknown, config?: AxiosRequestConfig): Promise => { + return newInstance.request({ ...config, method: 'POST', url, data }).then((res: AxiosResponse) => res.data); + }, + put: (url: string, data?: unknown, config?: AxiosRequestConfig): Promise => { + return newInstance.request({ ...config, method: 'PUT', url, data }).then((res: AxiosResponse) => res.data); + }, + delete: (url: string, config?: AxiosRequestConfig): Promise => { + return newInstance.request({ ...config, method: 'DELETE', url }).then((res: AxiosResponse) => res.data); + }, + patch: (url: string, data?: unknown, config?: AxiosRequestConfig): Promise => { + return newInstance.request({ ...config, method: 'PATCH', url, data }).then((res: AxiosResponse) => res.data); + }, + setDefaults: (_config: Partial): void => { + Object.assign(newInstance.defaults, _config); + }, + setBaseURL: (baseURL: string): void => { + newInstance.defaults.baseURL = baseURL; + }, + createInstance: (newConfig?: Partial): ApiClient => { + // 手动处理headers字段的类型转换 + const { headers, ...otherDefaults } = newInstance.defaults; + const configWithTypedHeaders: Partial = { + ...otherDefaults, + ...newConfig + }; + + // 只有当headers存在时才添加 + if (headers) { + // 手动转换headers字段，确保类型安全 + const convertedHeaders: Record = {}; + Object.entries(headers).forEach(([key, value]) => { + if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') { + convertedHeaders[key] = value; + } + }); + configWithTypedHeaders.headers = convertedHeaders; + } + + return createInstance(configWithTypedHeaders); + }, + addRequestInterceptor: ( + onFulfilled?: (_config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig | Promise, + onRejected?: (_error: unknown) => unknown + ): number => { + const handler = newInstance.interceptors.request.use(onFulfilled, onRejected); + newRequestInterceptors.push(handler); + return handler; + }, + addResponseInterceptor: ( + onFulfilled?: (_response: AxiosResponse) => AxiosResponse | Promise, + onRejected?: (_error: unknown) => unknown + ): number => { + const handler = newInstance.interceptors.response.use(onFulfilled, onRejected); + newResponseInterceptors.push(handler); + return handler; + }, + removeRequestInterceptor: (handler: number): void => { + const index = newRequestInterceptors.indexOf(handler); + if (index !== -1) { + newInstance.interceptors.request.eject(handler); + newRequestInterceptors.splice(index, 1); + } + }, + removeResponseInterceptor: (handler: number): void => { + const index = newResponseInterceptors.indexOf(handler); + if (index !== -1) { + newInstance.interceptors.response.eject(handler); + newResponseInterceptors.splice(index, 1); + } + } + }; + }; + + // 基础请求方法 + const request = async (config: AxiosRequestConfig): Promise => { + try { + const response = await instance.request(config); + return response.data; + } catch (error) { + // 直接使用ApiError.fromAxiosError静态方法处理错误 + return Promise.reject(ApiError.fromAxiosError(error as AxiosError)); + } + }; + + // HTTP方法简写 + const get = (url: string, config?: AxiosRequestConfig): Promise => { + return request({ ...config, method: 'GET', url }); + }; + + const post = (url: string, data?: unknown, config?: AxiosRequestConfig): Promise => { + return request({ ...config, method: 'POST', url, data }); + }; + + const put = (url: string, data?: unknown, config?: AxiosRequestConfig): Promise => { + return request({ ...config, method: 'PUT', url, data }); + }; + + const del = (url: string, config?: AxiosRequestConfig): Promise => { + return request({ ...config, method: 'DELETE', url }); + }; + + const patch = (url: string, data?: unknown, config?: AxiosRequestConfig): Promise => { + return request({ ...config, method: 'PATCH', url, data }); + }; + + return { + request, + get, + post, + put, + delete: del, + patch, + setDefaults, + setBaseURL, + createInstance, + addRequestInterceptor, + addResponseInterceptor, + removeRequestInterceptor, + removeResponseInterceptor + }; +}; + +// 默认实例（单例） +const apiClient = createApiClientInstance(); + +// 工厂函数 +const createApiClient = (config?: Partial) => { + return createApiClientInstance(config); +}; + +// 导出API客户端和工厂函数 +export { apiClient, createApiClient }; diff --git a/api/errors.ts b/api/errors.ts new file mode 100644 index 0000000..6efffd0 --- /dev/null +++ b/api/errors.ts @@ -0,0 +1,46 @@ +/** + * API错误处理 + */ +import type { AxiosError } from 'axios'; + +/** + * API错误接口 + */ +export interface IApiError { + code: number; + message: string; + details?: unknown; +} + +/** + * API错误类 + */ +export class ApiError extends Error implements IApiError { + public readonly code: number; + public readonly details: unknown; + + constructor(code: number, message: string, details?: unknown) { + super(message); + this.name = 'ApiError'; + this.code = code; + this.details = details; + } + + /** + * 从Axios错误创建API错误 + */ + static fromAxiosError(error: AxiosError): ApiError { + if (!error.response) { + return new ApiError(0, error.message || '网络错误'); + } + + const { status, data } = error.response; + const message = data && typeof data === 'object' && 'message' in data + ? data.message as string + : '请求失败'; + + return new ApiError(status, message, data); + } +} + + diff --git a/api/factory.ts b/api/factory.ts new file mode 100644 index 0000000..4a6ba16 --- /dev/null +++ b/api/factory.ts @@ -0,0 +1,40 @@ +import { apiClient, createApiClient } from './client'; +import type { AxiosRequestConfig } from 'axios'; +import { postApi } from './modules/post'; +import { userApi } from './modules/user'; +import { chatApi } from './modules/chat'; +import { modelApi } from './modules/model'; + +/** + * API 工厂函数，用于创建和管理 API 实例 + * 提供统一的 API 访问入口和配置管理 + */ +export const createApi = (config?: Partial) => { + const client = config ? createApiClient(config) : apiClient; + + return { + // 核心客户端 + client, + + // API 模块 - 使用提供的客户端或默认客户端 + modules: { + post: postApi(client), + user: userApi(client), + chat: chatApi(client), + model: modelApi(client) + }, + + // 便捷访问 + post: postApi(client), + user: userApi(client), + chat: chatApi(client), + model: modelApi(client) + }; +}; + +// 导出默认 API 实例 +export const api = createApi(); + +// 向后兼容的导出 +export { apiClient } from './client'; +export { postApi, userApi, chatApi, modelApi } from './modules'; diff --git a/api/index.ts b/api/index.ts new file mode 100644 index 0000000..d4020e4 --- /dev/null +++ b/api/index.ts @@ -0,0 +1,19 @@ +// 导出API工厂函数和默认实例 +export { createApi, api } from './factory'; + +// 导出API类型和配置 +export { + API_ENDPOINTS, + ApiStatusCode, + ApiErrorType, + DEFAULT_REQUEST_CONFIG, + DEFAULT_PAGINATION_CONFIG, + type ApiClient, + type ApiResponse, + type PaginatedResponse, + type ErrorResponse +} from './types'; + +// 向后兼容的导出 +export { apiClient } from './client'; +export { postApi, userApi, chatApi, modelApi } from './modules'; diff --git a/api/modules/chat.ts b/api/modules/chat.ts new file mode 100644 index 0000000..e5474c5 --- /dev/null +++ b/api/modules/chat.ts @@ -0,0 +1,48 @@ +import type { AxiosRequestConfig } from 'axios'; +import type { ApiClient } from '../types'; +import type { + CreateChatSessionRequest, + UpdateChatSessionRequest, + SendMessageRequest, + GetChatSessionsRequest, + GetChatSessionsResponse, + GetChatMessagesRequest, + GetChatMessagesResponse, + MarkMessagesAsReadRequest, + MarkMessagesAsReadResponse +} from '@/types/chat/api'; +import type { ChatSession, ChatMessage } from '@/types/chat/base'; + +// 聊天API服务工厂函数 +export const chatApi = (client: ApiClient) => ({ + // 创建聊天会话 + createSession: (data: CreateChatSessionRequest): Promise<{ session: ChatSession }> => { + return client.post('/chat/sessions', data); + }, + + // 更新聊天会话 + updateSession: ({ sessionId, ...data }: UpdateChatSessionRequest): Promise<{ session: ChatSession }> => { + return client.put(`/chat/sessions/${sessionId}`, data); + }, + + // 发送消息 + sendMessage: (data: SendMessageRequest): Promise<{ message: ChatMessage }> => { + return client.post(`/chat/sessions/${data.sessionId}/messages`, data); + }, + + // 获取聊天会话列表 + getSessions: (params?: GetChatSessionsRequest): Promise => { + const config: AxiosRequestConfig = params ? { params } : {}; + return client.get('/chat/sessions', config); + }, + + // 获取聊天消息 + getMessages: ({ sessionId, ...params }: GetChatMessagesRequest): Promise => { + return client.get(`/chat/sessions/${sessionId}/messages`, { params }); + }, + + // 标记消息已读 + markMessagesAsRead: ({ sessionId, messageIds }: MarkMessagesAsReadRequest): Promise => { + return client.post(`/chat/sessions/${sessionId}/read`, { messageIds }); + } +}); diff --git a/api/modules/index.ts b/api/modules/index.ts new file mode 100644 index 0000000..a5e65b5 --- /dev/null +++ b/api/modules/index.ts @@ -0,0 +1,14 @@ +import { apiClient } from '../client'; +import { postApi as createPostApi } from './post'; +import { userApi as createUserApi } from './user'; +import { chatApi as createChatApi } from './chat'; +import { modelApi as createModelApi } from './model'; + +// 导出工厂函数 +export { postApi as createPostApi, userApi as createUserApi, chatApi as createChatApi, modelApi as createModelApi }; + +// 向后兼容的默认实例 +export const postApi = createPostApi(apiClient); +export const userApi = createUserApi(apiClient); +export const chatApi = createChatApi(apiClient); +export const modelApi = createModelApi(apiClient); diff --git a/api/modules/model.ts b/api/modules/model.ts new file mode 100644 index 0000000..738df6d --- /dev/null +++ b/api/modules/model.ts @@ -0,0 +1,29 @@ +import type { AxiosRequestConfig } from 'axios'; +import type { ApiClient } from '../types'; +import type { + GetAIPlazaRequest, + GetAIPlazaResponse, + GetModelDetailRequest, + GetModelDetailResponse, + GetModelCommentsRequest, + GetModelCommentsResponse +} from '@/types/model/api'; + +// AI模型API服务工厂函数 +export const modelApi = (client: ApiClient) => ({ + // 获取AI模型广场数据 + getAIPlaza: (params?: GetAIPlazaRequest): Promise => { + const config: AxiosRequestConfig = params ? { params } : {}; + return client.get('/models/plaza', config); + }, + + // 获取模型详情 + getModelDetail: ({ modelId, ...params }: GetModelDetailRequest): Promise => { + return client.get(`/models/${modelId}`, { params }); + }, + + // 获取模型评论 + getModelComments: ({ modelId, ...params }: GetModelCommentsRequest): Promise => { + return client.get(`/models/${modelId}/comments`, { params }); + } +}); diff --git a/api/modules/post.ts b/api/modules/post.ts new file mode 100644 index 0000000..3097308 --- /dev/null +++ b/api/modules/post.ts @@ -0,0 +1,65 @@ +import type { AxiosRequestConfig } from 'axios'; +import type { ApiClient } from '../types'; +import type { + CreatePostRequest, + CreatePostResponse, + GetPostsRequest, + GetPostsResponse, + GetPostRequest, + GetPostResponse, + LikePostRequest, + LikePostResponse, + BookmarkPostRequest, + BookmarkPostResponse, + CreateCommentRequest, + CreateCommentResponse, + GetCommentsRequest, + GetCommentsResponse, + LikeCommentRequest, + LikeCommentResponse +} from '@/types/post/api'; + +// 帖子API服务工厂函数 +export const postApi = (client: ApiClient) => ({ + // 创建帖子 + createPost: (data: CreatePostRequest): Promise => { + return client.post('/posts', data); + }, + + // 获取帖子列表 + getPosts: (params: GetPostsRequest): Promise => { + const config: AxiosRequestConfig = { params }; + return client.get('/posts', config); + }, + + // 获取帖子详情 + getPost: ({ postId }: GetPostRequest): Promise => { + return client.get(`/posts/${postId}`); + }, + + // 点赞帖子 + likePost: ({ postId }: LikePostRequest): Promise => { + return client.put(`/posts/${postId}/like`); + }, + + // 收藏帖子 + bookmarkPost: ({ postId }: BookmarkPostRequest): Promise => { + return client.put(`/posts/${postId}/bookmark`); + }, + + // 创建评论 + createComment: (data: CreateCommentRequest): Promise => { + return client.post(`/posts/${data.postId}/comments`, data); + }, + + // 获取评论列表 + getComments: (params: GetCommentsRequest): Promise => { + const { postId, ...queryParams } = params; + return client.get(`/posts/${postId}/comments`, { params: queryParams }); + }, + + // 点赞评论 + likeComment: ({ commentId }: LikeCommentRequest): Promise => { + return client.put(`/comments/${commentId}/like`); + } +}); diff --git a/api/modules/user.ts b/api/modules/user.ts new file mode 100644 index 0000000..2711ed3 --- /dev/null +++ b/api/modules/user.ts @@ -0,0 +1,51 @@ +import type { ApiClient } from '../types'; +import type { + LoginRequest, + LoginResponse, + RegisterRequest, + RegisterResponse, + RefreshTokenRequest, + RefreshTokenResponse, + UserProfileUpdateRequest, + UserProfileUpdateResponse, + UserFollowRequest, + UserFollowResponse +} from '@/types/user'; + +// 用户API服务工厂函数 +export const userApi = (client: ApiClient) => ({ + // 用户登录 + login: (data: LoginRequest): Promise => { + return client.post('/auth/login', data); + }, + + // 用户注册 + register: (data: RegisterRequest): Promise => { + return client.post('/auth/register', data); + }, + + // 刷新令牌 + refreshToken: (data: RefreshTokenRequest): Promise => { + return client.post('/auth/refresh', data); + }, + + // 获取用户档案 + getProfile: (): Promise => { + return client.get('/user/profile'); + }, + + // 更新用户档案 + updateProfile: (data: UserProfileUpdateRequest): Promise => { + return client.put('/user/profile', data); + }, + + // 关注用户 + followUser: ({ userId }: UserFollowRequest): Promise => { + return client.put(`/user/follow/${userId}`); + }, + + // 取消关注用户 + unfollowUser: ({ userId }: UserFollowRequest): Promise => { + return client.delete(`/user/follow/${userId}`); + } +}); diff --git a/api/types.d.ts b/api/types.d.ts new file mode 100644 index 0000000..eecf3a7 --- /dev/null +++ b/api/types.d.ts @@ -0,0 +1,119 @@ +/** + * API 类型定义文件 + */ + +import type { AxiosResponse, AxiosRequestConfig, InternalAxiosRequestConfig } from 'axios'; + +// API客户端接口定义 +export interface ApiClient { + request(config: AxiosRequestConfig): Promise; + get(url: string, config?: AxiosRequestConfig): Promise; + post(url: string, data?: unknown, config?: AxiosRequestConfig): Promise; + put(url: string, data?: unknown, config?: AxiosRequestConfig): Promise; + delete(url: string, config?: AxiosRequestConfig): Promise; + patch(url: string, data?: unknown, config?: AxiosRequestConfig): Promise; + setDefaults(config: Partial): void; + setBaseURL(baseURL: string): void; + createInstance(config?: Partial): ApiClient; + addRequestInterceptor( + onFulfilled?: (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig | Promise, + onRejected?: (error: unknown) => unknown + ): number; + addResponseInterceptor( + onFulfilled?: (response: AxiosResponse) => AxiosResponse | Promise, + onRejected?: (error: unknown) => unknown + ): number; + removeRequestInterceptor(handler: number): void; + removeResponseInterceptor(handler: number): void; +} + +// API响应接口 +export interface ApiResponse { + success: boolean; + data: T; + message?: string; + code?: number; +} + +// 分页响应接口 +export interface PaginatedResponse { + items: T[]; + total: number; + page: number; + pageSize: number; + totalPages: number; +} + +// 错误响应接口 +export interface ErrorResponse { + success: false; + message: string; + code?: number; + details?: unknown; +} + +// API端点常量 +export const API_ENDPOINTS = { + // 用户相关 + USER_LOGIN: '/auth/login', + USER_REGISTER: '/auth/register', + USER_LOGOUT: '/auth/logout', + USER_PROFILE: '/user/profile', + USER_CURRENT: '/auth/me', + + // 聊天相关 + CHAT_LIST: '/chat/list', + CHAT_CREATE: '/chat/create', + CHAT_DETAIL: '/chat/detail', + CHAT_DELETE: '/chat/delete', + CHAT_MESSAGE: '/chat/message', + + // 模型相关 + MODEL_LIST: '/model/list', + MODEL_DETAIL: '/model/detail', + + // 帖子相关 + POST_LIST: '/post/list', + POST_DETAIL: '/post/detail', + POST_CREATE: '/post/create', + POST_UPDATE: '/post/update', + POST_DELETE: '/post/delete' +} as const; + +// API状态码 +export const ApiStatusCode = { + OK: 200, + CREATED: 201, + NO_CONTENT: 204, + BAD_REQUEST: 400, + UNAUTHORIZED: 401, + FORBIDDEN: 403, + NOT_FOUND: 404, + INTERNAL_SERVER_ERROR: 500 +} as const; + +// API错误类型 +export const ApiErrorType = { + NETWORK_ERROR: 'NETWORK_ERROR', + VALIDATION_ERROR: 'VALIDATION_ERROR', + AUTHENTICATION_ERROR: 'AUTHENTICATION_ERROR', + AUTHORIZATION_ERROR: 'AUTHORIZATION_ERROR', + NOT_FOUND_ERROR: 'NOT_FOUND_ERROR', + SERVER_ERROR: 'SERVER_ERROR', + UNKNOWN_ERROR: 'UNKNOWN_ERROR' +} as const; + +// 默认请求配置 +export const DEFAULT_REQUEST_CONFIG = { + timeout: 10000, + headers: { + 'Content-Type': 'application/json' + }, + withCredentials: true +} as const; + +// 默认分页配置 +export const DEFAULT_PAGINATION_CONFIG = { + page: 1, + pageSize: 20 +} as const; diff --git a/auth/README.md b/auth/README.md new file mode 100644 index 0000000..4a91730 --- /dev/null +++ b/auth/README.md @@ -0,0 +1,217 @@ +# 认证模块 + +## 概述 + +认证模块提供基于Session的认证机制，支持用户登录、注册、登出和会话管理功能。该模块采用适配器模式，支持多种存储方式（Cookie、LocalStorage、内存），以适应不同的运行环境（浏览器、SSR等）。 + +## 核心组件 + +### 1. 认证服务 (AuthService) + +`AuthService` 接口定义了认证相关的核心功能： + +- `login(credentials)`: 用户登录 +- `register(userData)`: 用户注册 +- `logout()`: 用户登出 +- `isAuthenticated()`: 检查是否已认证 +- `getCurrentUser()`: 获取当前用户信息 +- `refreshSession()`: 刷新会话 +- `getSession()`: 获取会话信息 + +### 2. 会话管理器 (SessionManager) + +`SessionManager` 负责管理用户会话状态，包括： + +- 会话的创建、验证、刷新和清除 +- 用户信息的获取和缓存 +- 会话状态的持久化存储 + +### 3. 存储适配器 (StorageAdapter) + +`StorageAdapter` 提供统一的存储接口，支持多种存储方式： + +- `CookieStorageAdapter`: 使用Cookie存储，适用于SSR环境 +- `LocalStorageAdapter`: 使用浏览器LocalStorage存储 +- `MemoryStorageAdapter`: 使用内存存储，适用于测试或临时会话 + +### 4. 事件管理器 (EventManager) + +`EventManager` 负责管理认证相关事件： + +- 登录事件 (`login`) +- 注册事件 (`register`) +- 登出事件 (`logout`) +- 错误事件 (`error`) + +### 5. 类型定义 + +模块包含完整的TypeScript类型定义，确保类型安全。 + +## 使用方法 + +### 基本使用 + +```typescript +import { authService } from '@/auth'; + +// 用户登录 +const loginResult = await authService.login({ + username: 'user@example.com', + password: 'password123' +}); + +if (loginResult.success) { + console.log('登录成功', loginResult.data); +} else { + console.error('登录失败', loginResult.error); +} + +// 检查认证状态 +if (await authService.isAuthenticated()) { + // 获取当前用户信息 + const userResult = await authService.getCurrentUser(); + if (userResult.success) { + console.log('当前用户:', userResult.data); + } +} + +// 用户登出 +await authService.logout(); +``` + +### 测试环境使用 + +```typescript +import { getAuthService, resetAuthService } from '@/auth'; + +// 在测试前重置服务实例 +resetAuthService(); + +// 获取新的服务实例 +const authService = getAuthService(); +``` + +### 自定义存储方式 + +```typescript +import { createStorageAdapter } from '@/auth'; + +// 创建自定义存储适配器 +const customStorage = createStorageAdapter('localStorage'); + +// 注意：当前版本使用单例模式，自定义存储需要修改auth-service.ts中的实现 +``` + +### 使用自定义存储适配器 + +```typescript +import { createAuthService, createStorageAdapter } from '@/auth'; + +// 创建自定义Cookie存储适配器 +const cookieStorage = createStorageAdapter('cookie', { + domain: '.example.com', + secure: true, + httpOnly: false, + sameSite: 'strict' +}); + +// 使用自定义存储适配器 +const authService = createAuthService(undefined, cookieStorage); +``` + +### 事件监听 + +```typescript +import { createAuthService, createEventManager } from '@/auth'; + +const eventManager = createEventManager(); +const authService = createAuthService(); + +// 监听登录事件 +eventManager.on('login', (data) => { + console.log('用户登录:', data.user); +}); + +// 监听登出事件 +eventManager.on('logout', () => { + console.log('用户已登出'); +}); +``` + +## 会话管理 + +### 会话存储 + +会话信息通过StorageAdapter存储，默认使用Cookie存储，以支持SSR环境。会话信息包括： + +- `sessionId`: 会话ID +- `userId`: 用户ID +- `expiresAt`: 过期时间 +- `createdAt`: 创建时间 + +### 会话验证 + +SessionManager会自动验证会话的有效性： + +1. 检查本地是否存在会话ID +2. 验证会话是否过期 +3. 向服务器验证会话有效性 +4. 自动刷新过期会话 + +### 会话刷新 + +当会话即将过期时，SessionManager会自动尝试刷新会话： + +1. 使用当前会话ID请求刷新 +2. 更新本地存储的会话信息 +3. 清除缓存的用户信息，下次获取时重新请求 + +## API端点 + +认证模块需要以下API端点： + +- `POST /auth/login`: 用户登录 +- `POST /auth/register`: 用户注册 +- `POST /auth/logout`: 用户登出 +- `GET /auth/session/:sessionId`: 获取会话信息 +- `POST /auth/session/refresh`: 刷新会话 +- `GET /auth/user/:userId`: 获取用户信息 + +## 设计模式 + +认证模块采用以下设计模式： + +1. **适配器模式**: 通过StorageAdapter接口支持多种存储方式 +2. **工厂模式**: 提供createAuthService等工厂函数简化实例创建 +3. **观察者模式**: 通过EventManager实现事件发布订阅 +4. **策略模式**: 不同存储方式采用不同策略 + +## 安全考虑 + +1. **会话安全**: 使用HttpOnly Cookie存储会话ID，防止XSS攻击 +2. **CSRF防护**: 通过SameSite Cookie属性防止CSRF攻击 +3. **会话过期**: 设置合理的会话过期时间，并支持自动刷新 +4. **HTTPS**: 在生产环境中使用HTTPS传输敏感数据 + +## SSR支持 + +认证模块完全支持SSR环境： + +1. 默认使用Cookie存储，可在服务器端读取 +2. 提供统一的StorageAdapter接口，可针对不同环境实现 +3. 会话状态可在服务器和客户端之间同步 + +## 测试 + +认证模块包含完整的单元测试，覆盖： + +- 会话管理功能 +- 存储适配器功能 +- 认证服务功能 +- 错误处理 + +运行测试： + +```bash +npm test auth +``` \ No newline at end of file diff --git a/auth/auth-service.ts b/auth/auth-service.ts new file mode 100644 index 0000000..6e35cfc --- /dev/null +++ b/auth/auth-service.ts @@ -0,0 +1,170 @@ +/** + * 认证服务实现 + * 集成事件管理、会话管理和存储适配器功能 + * 完全实现AuthService接口定义 + */ +import type { ApiClient } from '@/api/types'; +import type { User } from '@/types'; +import type { + AuthService, + AuthEventType +} from './types'; +import type { + LoginRequest, + LoginResponse, + RegisterRequest, + RegisterResponse +} from '@/types/user'; +import { AuthError } from './errors'; +import { authEventManager } from './event-manager'; +import { createSessionManager } from './session-manager'; +import { createStorageAdapter } from './storage-adapter'; + +/** + * 默认认证服务实现 + */ +export class DefaultAuthService implements AuthService { + private readonly apiClient: ApiClient; + private readonly sessionManager: ReturnType; + private readonly storage: ReturnType; + + constructor(apiClient: ApiClient) { + this.apiClient = apiClient; + this.storage = createStorageAdapter('memory'); + this.sessionManager = createSessionManager(apiClient, this.storage); + } + + /** + * 用户登录 + * @param credentials 登录凭证 + * @returns 登录响应，包含用户信息和会话ID + */ + async login(credentials: LoginRequest): Promise { + try { + const response = await this.apiClient.post('/auth/login', credentials); + + // 触发登录成功事件 + authEventManager.emit('login', response.user); + + // 更新会话管理器中的用户信息 + await this.sessionManager.getUserInfo(); + + return response; + } catch (error) { + throw AuthError.loginFailed('Login failed', error); + } + } + + /** + * 用户注册 + * @param userData 注册数据 + * @returns 注册响应，包含用户信息和会话ID + */ + async register(userData: RegisterRequest): Promise { + try { + const response = await this.apiClient.post('/auth/register', userData); + + // 触发注册成功事件 + authEventManager.emit('register', response.user); + + // 更新会话管理器中的用户信息 + await this.sessionManager.getUserInfo(); + + return response; + } catch (error) { + throw AuthError.registerFailed('Registration failed', error); + } + } + + /** + * 用户登出 + * 调用服务器端登出API，清除会话 + */ + async logout(): Promise { + try { + // 调用服务器端登出API + await this.apiClient.post('/auth/logout'); + + // 清除本地缓存 + this.sessionManager.clearCache(); + + // 触发登出事件 + authEventManager.emit('logout'); + } catch (error) { + // 即使API调用失败，也要清除本地状态 + this.sessionManager.clearCache(); + throw AuthError.logoutFailed('Logout failed', error); + } + } + + /** + * 获取当前用户信息 + * @returns 当前用户信息 + */ + async getCurrentUser(): Promise { + try { + const user = await this.sessionManager.getUserInfo(); + if (!user) { + throw AuthError.notAuthenticated(); + } + return user; + } catch (error) { + // 如果已经是AuthError，直接抛出 + if (error instanceof AuthError) { + throw error; + } + throw AuthError.userNotFound('Failed to get current user', error); + } + } + + /** + * 检查用户是否已认证 + * @returns 是否已认证 + */ + async isAuthenticated(): Promise { + try { + return await this.sessionManager.isAuthenticated(); + } catch (error) { + // 如果已经是AuthError，直接抛出 + if (error instanceof AuthError) { + throw error; + } + throw AuthError.unknown('Authentication check failed', error); + } + } + + /** + * 添加认证事件监听器 + * @param event 事件类型 + * @param listener 事件监听器 + */ + on(event: AuthEventType, listener: (...args: unknown[]) => void): void { + authEventManager.on(event, listener); + } + + /** + * 移除认证事件监听器 + * @param event 事件类型 + * @param listener 事件监听器 + */ + off(event: AuthEventType, listener: (...args: unknown[]) => void): void { + authEventManager.off(event, listener); + } + + /** + * 清除本地缓存 + * 不影响服务器端session + */ + clearCache(): void { + this.sessionManager.clearCache(); + } +} + +/** + * 创建认证服务实例 + * @param apiClient API客户端 + * @returns 认证服务实例 + */ +export function createAuthService(apiClient: ApiClient): AuthService { + return new DefaultAuthService(apiClient); +} diff --git a/auth/errors.ts b/auth/errors.ts new file mode 100644 index 0000000..d42f5fe --- /dev/null +++ b/auth/errors.ts @@ -0,0 +1,67 @@ +/** + * 认证模块错误处理 + */ + +/** + * 认证错误类 + */ +export class AuthError extends Error { + public readonly code: string; + public readonly details: unknown; + + constructor(code: string, message: string, details?: unknown) { + super(message); + this.name = 'AuthError'; + this.code = code; + this.details = details; + } + + /** + * 创建登录失败错误 + */ + static loginFailed(message: string, details?: unknown): AuthError { + return new AuthError('LOGIN_FAILED', message, details); + } + + /** + * 创建登出失败错误 + */ + static logoutFailed(message: string, details?: unknown): AuthError { + return new AuthError('LOGOUT_FAILED', message, details); + } + + /** + * 创建注册失败错误 + */ + static registerFailed(message: string, details?: unknown): AuthError { + return new AuthError('REGISTER_FAILED', message, details); + } + + /** + * 创建用户未找到错误 + */ + static userNotFound(message: string, details?: unknown): AuthError { + return new AuthError('USER_NOT_FOUND', message, details); + } + + /** + * Session过期 + */ + static sessionExpired(message: string, details?: unknown): AuthError { + return new AuthError('SESSION_EXPIRED', message, details); + } + + /** + * Session未认证 + */ + static notAuthenticated(message: string = 'User not authenticated', details?: unknown): AuthError { + return new AuthError('NOT_AUTHENTICATED', message, details); + } + + /** + * 通用未知报错 + */ + static unknown(message: string = 'Unknown authentication error', details?: unknown): AuthError { + return new AuthError('UNKNOWN', message, details); + } +} diff --git a/auth/event-manager.ts b/auth/event-manager.ts new file mode 100644 index 0000000..a7dc71e --- /dev/null +++ b/auth/event-manager.ts @@ -0,0 +1,65 @@ +/** + * 认证事件管理器 + * 管理认证相关的事件监听和触发 + */ +import type { AuthEventType, AuthEventListener } from './types'; +import { AuthError } from './errors'; + +/** + * 认证事件管理器 + */ +export class AuthEventManager { + private listeners: Map = new Map(); + + /** + * 添加事件监听器 + */ + on(event: AuthEventType, listener: AuthEventListener): void { + if (!this.listeners.has(event)) { + this.listeners.set(event, []); + } + const eventListeners = this.listeners.get(event); + if (eventListeners) { + eventListeners.push(listener); + } + } + + /** + * 移除事件监听器 + */ + off(event: AuthEventType, listener: AuthEventListener): void { + const eventListeners = this.listeners.get(event); + if (eventListeners) { + const index = eventListeners.indexOf(listener); + if (index !== -1) { + eventListeners.splice(index, 1); + } + } + } + + /** + * 触发事件 + */ + emit(event: AuthEventType, ...args: unknown[]): void { + const eventListeners = this.listeners.get(event); + if (eventListeners) { + eventListeners.forEach(listener => { + try { + listener(...args); + } catch (error) { + throw AuthError.unknown(`Error in auth event listener for ${event}`, error); + } + }); + } + } + + /** + * 清除所有监听器 + */ + clear(): void { + this.listeners.clear(); + } +} + +// 创建全局事件管理器实例 +export const authEventManager = new AuthEventManager(); diff --git a/auth/index.ts b/auth/index.ts new file mode 100644 index 0000000..c3c4485 --- /dev/null +++ b/auth/index.ts @@ -0,0 +1,22 @@ +/** + * 认证模块入口文件 + */ + +// 导出类型定义 +export type { + AuthEventType, + AuthEventListener, + StorageAdapter, + AuthService, + SessionManager +} from './types'; + +// 导出实现类 +export { DefaultAuthService } from './auth-service'; +export { DefaultSessionManager } from './session-manager'; +export { AuthEventManager, authEventManager } from './event-manager'; +export { MemoryStorageAdapter, createStorageAdapter } from './storage-adapter'; + +// 导出工厂函数 +export { createAuthService } from './auth-service'; +export { createSessionManager } from './session-manager'; diff --git a/auth/session-manager.ts b/auth/session-manager.ts new file mode 100644 index 0000000..c8134dc --- /dev/null +++ b/auth/session-manager.ts @@ -0,0 +1,92 @@ +/** + * 会话管理器 + * 负责查询用户认证状态，不主动管理session + * session完全由服务器端控制，前端只通过API查询状态 + */ +import type { ApiClient } from '@/api/types'; +import type { User } from '@/types'; +import type { StorageAdapter } from './types'; +import { authEventManager } from './event-manager'; + +export class DefaultSessionManager { + private readonly apiClient: ApiClient; + private readonly storage: StorageAdapter; + private currentUser: User | null = null; + + constructor(apiClient: ApiClient, storage: StorageAdapter) { + this.apiClient = apiClient; + this.storage = storage; + } + + /** + * 检查是否已认证 + * 通过API调用验证用户认证状态，而不是直接访问cookie + * @returns 是否已认证 + */ + async isAuthenticated(): Promise { + try { + // 通过调用API验证认证状态 + await this.getUserInfo(); + return true; + } catch (error) { + // 如果认证失败，触发session_expired事件 + authEventManager.emit('session_expired', error); + return false; + } + } + + /** + * 获取当前用户信息 + * 幂等操作，每次都从服务器获取最新用户信息 + * @returns 用户信息 + * @throws 当获取用户信息失败时抛出错误 + */ + async getUserInfo(): Promise { + try { + // API客户端的get方法已经返回解构后的数据，不需要访问.data + const response = await this.apiClient.get<{ user: User }>('/auth/me'); + this.currentUser = response.user; + // 如果成功获取用户信息，触发session_authenticated事件 + authEventManager.emit('session_authenticated', this.currentUser); + return this.currentUser; + } catch (error) { + this.currentUser = null; + // 如果获取用户信息失败，触发session_expired事件 + authEventManager.emit('session_expired', error); + // 抛出错误，让调用者处理 + throw error; + } + } + + /** + * 清除本地缓存 + * 不影响服务器端session，只清除前端缓存 + */ + clearCache(): void { + this.currentUser = null; + // 清除存储适配器中的所有项（如果支持） + if ('clear' in this.storage && typeof this.storage.clear === 'function') { + this.storage.clear(); + } else { + // 如果不支持clear方法，逐个删除已知项 + const keys = ['user_preferences', 'ui_state']; // 示例键 + keys.forEach(key => this.storage.removeItem(key)); + } + // 触发session_logout事件 + authEventManager.emit('session_logout'); + } +} + +/** + * 创建会话管理器 + * @param apiClient API客户端 + * @param storage 存储适配器，仅用于非敏感数据缓存 + * @returns 会话管理器实例 + */ +export function createSessionManager( + apiClient: ApiClient, + storage: StorageAdapter +): DefaultSessionManager { + return new DefaultSessionManager(apiClient, storage); +} + diff --git a/auth/storage-adapter.ts b/auth/storage-adapter.ts new file mode 100644 index 0000000..e9802dd --- /dev/null +++ b/auth/storage-adapter.ts @@ -0,0 +1,55 @@ +/** + * 存储适配器接口 + * 提供统一的存储接口，用于非敏感数据的临时存储 + * 注意：此存储适配器不用于session管理，session完全由服务器端控制 + */ +import type { StorageAdapter } from './types'; + +/** + * 内存存储适配器 + * 适用于非敏感数据的临时存储，如UI状态、用户偏好设置等 + */ +export class MemoryStorageAdapter implements StorageAdapter { + private storage: Record = {}; + + getItem(key: string): string | null { + return this.storage[key] || null; + } + + setItem(key: string, value: string): void { + this.storage[key] = value; + } + + removeItem(key: string): void { + delete this.storage[key]; + } + + /** + * 清空所有存储项 + */ + clear(): void { + this.storage = {}; + } + + /** + * 获取所有存储键 + * @returns 存储键数组 + */ + keys(): string[] { + return Object.keys(this.storage); + } +} + +/** + * 创建存储适配器 + * @param type 存储类型，目前只支持memory + * @returns 存储适配器实例 + */ +export function createStorageAdapter(type: 'memory' = 'memory'): StorageAdapter { + switch (type) { + case 'memory': + return new MemoryStorageAdapter(); + default: + return new MemoryStorageAdapter(); + } +} diff --git a/auth/types.d.ts b/auth/types.d.ts new file mode 100644 index 0000000..27a3155 --- /dev/null +++ b/auth/types.d.ts @@ -0,0 +1,85 @@ +/** + * 认证模块类型定义 + */ + +import type { AxiosRequestConfig } from 'axios'; +import type { User } from '@/types'; +import type { + LoginRequest, + LoginResponse, + RegisterRequest, + RegisterResponse +} from '@/types/user'; + +// 事件类型定义 +export type AuthEventType = 'login' | 'logout' | 'register' | 'session_expired' | 'session_authenticated' | 'session_logout'; + +// 事件监听器类型 +export type AuthEventListener = (...args: unknown[]) => void; + +// 存储适配器接口 - 仅用于非敏感数据存储，不涉及session管理 +export interface StorageAdapter { + /** + * 获取存储项 + * @param key 存储键 + * @returns 存储值或null + */ + getItem(key: string): string | null; + + /** + * 设置存储项 + * @param key 存储键 + * @param value 存储值 + */ + setItem(key: string, value: string): void; + + /** + * 删除存储项 + * @param key 存储键 + */ + removeItem(key: string): void; + + /** + * 清空所有存储项 + */ + clear(): void; + + /** + * 获取所有存储键 + * @returns 存储键数组 + */ + keys(): string[]; +} + +// 认证服务接口 +export interface AuthService { + login(credentials: LoginRequest): Promise; + register(userData: RegisterRequest): Promise; + logout(): Promise; + getCurrentUser(): Promise; + isAuthenticated(): Promise; // 改为异步，通过getUser验证 + + // 事件管理方法 + on(event: AuthEventType, listener: AuthEventListener): void; + off(event: AuthEventType, listener: AuthEventListener): void; + + // 会话管理方法 + clearCache(): void; +} + +// 会话管理器接口 - 仅作为状态查询器，不主动管理session +export interface SessionManager { + // 通过getUser验证用户认证状态，而不是直接访问cookie + isAuthenticated(): Promise; + // 获取当前用户信息，幂等操作 + getUserInfo(): Promise; + // 清除本地缓存，不影响服务器端session + clearCache(): void; +} + +// 扩展 Axios 请求配置以支持认证选项 +declare module 'axios' { + interface AxiosRequestConfig { + skipAuth?: boolean; + } +} diff --git a/eslint.config.js b/eslint.config.js new file mode 100644 index 0000000..826e9db --- /dev/null +++ b/eslint.config.js @@ -0,0 +1,137 @@ +import js from '@eslint/js'; +import typescript from '@typescript-eslint/eslint-plugin'; +import typescriptParser from '@typescript-eslint/parser'; + +export default [ + js.configs.recommended, + { + ignores: [ + 'test/**', + 'dist/**', + 'node_modules/**', + 'coverage/**', + '*.config.js', + '*.config.ts', + ], + }, + // 类型定义文件特殊规则 - 必须放在通用TypeScript规则之前 + { + files: ['**/*.d.ts'], + languageOptions: { + parser: typescriptParser, + parserOptions: { sourceType: 'module', ecmaVersion: 'latest' }, + }, + plugins: { + '@typescript-eslint': typescript, + }, + rules: { + '@typescript-eslint/no-unused-vars': 'off', + 'no-unused-vars': 'off', + }, + }, + // utils目录特殊规则 + { + files: ['utils/**/*.ts'], + languageOptions: { + parser: typescriptParser, + parserOptions: { sourceType: 'module', ecmaVersion: 'latest'}, + globals: { + setTimeout: 'readonly', + clearTimeout: 'readonly', + }, + }, + plugins: { + '@typescript-eslint': typescript, + }, + rules: { + '@typescript-eslint/no-unused-vars': ['error', { + argsIgnorePattern: '^_', + varsIgnorePattern: '^[A-Z_]+$' + }], + 'no-undef': 'off', + 'no-unused-vars': 'off' + } + }, + // 测试文件特殊规则 + { + files: ['test/**/*.ts', '**/*.test.ts', '**/*.spec.ts'], + languageOptions: { + parser: typescriptParser, + parserOptions: { sourceType: 'module', ecmaVersion: 'latest'}, + globals: { + describe: 'readonly', + it: 'readonly', + test: 'readonly', + expect: 'readonly', + beforeEach: 'readonly', + afterEach: 'readonly', + beforeAll: 'readonly', + afterAll: 'readonly', + vi: 'readonly', + }, + }, + plugins: { + '@typescript-eslint': typescript, + }, + rules: { + 'no-unused-vars': 'off', + // 测试文件中放宽未使用变量的限制 + '@typescript-eslint/no-unused-vars': 'off', + 'no-unused-vars': 'off', + // 允许使用any类型 + '@typescript-eslint/no-explicit-any': 'off', + // 允许非空断言 + '@typescript-eslint/no-non-null-assertion': 'off', + // 允许使用console + 'no-console': 'off', + // 放宽行长度限制 + 'max-len': 'off', + // 允许尾随逗号 + 'comma-dangle': 'off', + } + }, + // 通用TypeScript规则 + { + files: ['**/*.ts', '**/*.tsx'], + languageOptions: { + parser: typescriptParser, + parserOptions: { + ecmaVersion: 'latest', + sourceType: 'module', + }, + }, + plugins: { + '@typescript-eslint': typescript, + }, + rules: { + 'no-unused-vars': 'off', + // TypeScript 规则 - 放宽限制 + '@typescript-eslint/no-unused-vars': ['error', { + varsIgnorePattern: '^(_|.*[A-Z_]+.*)$', + argsIgnorePattern: '^_' + }], + '@typescript-eslint/explicit-function-return-type': 'off', + '@typescript-eslint/explicit-module-boundary-types': 'off', + '@typescript-eslint/no-explicit-any': 'warn', // 恢复为警告级别 + '@typescript-eslint/no-non-null-assertion': 'warn', + '@typescript-eslint/no-var-requires': 'error', + + // 通用规则 + 'no-console': 'warn', + 'no-debugger': 'error', + 'no-var': 'error', + 'prefer-const': 'error', + 'object-shorthand': 'error', + 'prefer-template': 'error', + + // 代码风格 - 放宽限制 + 'indent': ['error', 2, { SwitchCase: 1 }], + 'quotes': ['error', 'single', { avoidEscape: true }], + 'semi': ['error', 'always'], + 'comma-dangle': ['error', 'never'], // 禁止尾随逗号 + 'eol-last': ['warn', 'always'], // 降级为警告 + 'no-trailing-spaces': 'warn', // 降级为警告 + 'max-len': ['warn', { code: 150, ignoreUrls: true }], // 增加行长度限制 + }, + }, +]; \ No newline at end of file diff --git a/index.ts b/index.ts new file mode 100644 index 0000000..97e352b --- /dev/null +++ b/index.ts @@ -0,0 +1,11 @@ +// 导出所有类型定义 +export * from './types'; + +// 导出API客户端和模块 +export * from './api'; + +// 导出鉴权相关功能 +export * from './auth'; + +// 导出工具函数 +export * from './utils'; diff --git a/package.json b/package.json new file mode 100644 index 0000000..5079549 --- /dev/null +++ b/package.json @@ -0,0 +1,34 @@ +{ + "name": "knowai-core", + "version": "1.0.0", + "type": "module", + "description": "负责准备视觉层会用到的逻辑函数、常用工具函数封装以及鉴权函数封装。负责维护统一接口。", + "main": "dist/index.js", + "types": "dist/index.d.ts", + "files": [ + "dist" + ], + "scripts": { + "type-check": "tsc --noemit", + "build": "tsc --project tsconfig.json", + "build:single": "tsc", + "dev": "tsc --watch", + "test": "vitest --run", + "lint": "eslint .", + "clean": "rm -rf dist" + }, + "dependencies": { + "axios": "^1.11.0" + }, + "devDependencies": { + "@eslint/js": "^9.39.1", + "@types/lodash": "^4.14.0", + "@types/node": "^20.0.0", + "@typescript-eslint/eslint-plugin": "^8.46.3", + "@typescript-eslint/parser": "^8.46.3", + "@vitest/coverage-v8": "^0.34.1", + "eslint": "^9.39.1", + "typescript": "^5.2.0", + "vitest": "^0.34.1" + } +} \ No newline at end of file diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml new file mode 100644 index 0000000..353cc8c --- /dev/null +++ b/pnpm-lock.yaml @@ -0,0 +1,2338 @@ +lockfileVersion: '9.0' + +settings: + autoInstallPeers: true + excludeLinksFromLockfile: false + +importers: + + .: + dependencies: + axios: + specifier: ^1.11.0 + version: 1.13.2 + devDependencies: + '@eslint/js': + specifier: ^9.39.1 + version: 9.39.1 + '@types/lodash': + specifier: ^4.14.0 + version: 4.17.20 + '@types/node': + specifier: ^20.0.0 + version: 20.19.24 + '@typescript-eslint/eslint-plugin': + specifier: ^8.46.3 + version: 8.46.3(@typescript-eslint/parser@8.46.3(eslint@9.39.1)(typescript@5.9.3))(eslint@9.39.1)(typescript@5.9.3) + '@typescript-eslint/parser': + specifier: ^8.46.3 + version: 8.46.3(eslint@9.39.1)(typescript@5.9.3) + '@vitest/coverage-v8': + specifier: ^0.34.1 + version: 0.34.6(vitest@0.34.6) + eslint: + specifier: ^9.39.1 + version: 9.39.1 + typescript: + specifier: ^5.2.0 + version: 5.9.3 + vitest: + specifier: ^0.34.1 + version: 0.34.6 + +packages: + + '@ampproject/remapping@2.3.0': + resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==} + engines: {node: '>=6.0.0'} + + '@bcoe/v8-coverage@0.2.3': + resolution: {integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==} + + '@esbuild/aix-ppc64@0.21.5': + resolution: {integrity: sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==} + engines: {node: '>=12'} + cpu: [ppc64] + os: [aix] + + '@esbuild/android-arm64@0.21.5': + resolution: {integrity: sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==} + engines: {node: '>=12'} + cpu: [arm64] + os: [android] + + '@esbuild/android-arm@0.21.5': + resolution: {integrity: sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==} + engines: {node: '>=12'} + cpu: [arm] + os: [android] + + '@esbuild/android-x64@0.21.5': + resolution: {integrity: sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==} + engines: {node: '>=12'} + cpu: [x64] + os: [android] + + '@esbuild/darwin-arm64@0.21.5': + resolution: {integrity: sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==} + engines: {node: '>=12'} + cpu: [arm64] + os: [darwin] + + '@esbuild/darwin-x64@0.21.5': + resolution: {integrity: sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==} + engines: {node: '>=12'} + cpu: [x64] + os: [darwin] + + '@esbuild/freebsd-arm64@0.21.5': + resolution: {integrity: sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==} + engines: {node: '>=12'} + cpu: [arm64] + os: [freebsd] + + '@esbuild/freebsd-x64@0.21.5': + resolution: {integrity: sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==} + engines: {node: '>=12'} + cpu: [x64] + os: [freebsd] + + '@esbuild/linux-arm64@0.21.5': + resolution: {integrity: sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==} + engines: {node: '>=12'} + cpu: [arm64] + os: [linux] + + '@esbuild/linux-arm@0.21.5': + resolution: {integrity: sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==} + engines: {node: '>=12'} + cpu: [arm] + os: [linux] + + '@esbuild/linux-ia32@0.21.5': + resolution: {integrity: sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==} + engines: {node: '>=12'} + cpu: [ia32] + os: [linux] + + '@esbuild/linux-loong64@0.21.5': + resolution: {integrity: sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==} + engines: {node: '>=12'} + cpu: [loong64] + os: [linux] + + '@esbuild/linux-mips64el@0.21.5': + resolution: {integrity: sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==} + engines: {node: '>=12'} + cpu: [mips64el] + os: [linux] + + '@esbuild/linux-ppc64@0.21.5': + resolution: {integrity: sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==} + engines: {node: '>=12'} + cpu: [ppc64] + os: [linux] + + '@esbuild/linux-riscv64@0.21.5': + resolution: {integrity: sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==} + engines: {node: '>=12'} + cpu: [riscv64] + os: [linux] + + '@esbuild/linux-s390x@0.21.5': + resolution: {integrity: sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==} + engines: {node: '>=12'} + cpu: [s390x] + os: [linux] + + '@esbuild/linux-x64@0.21.5': + resolution: {integrity: sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==} + engines: {node: '>=12'} + cpu: [x64] + os: [linux] + + '@esbuild/netbsd-x64@0.21.5': + resolution: {integrity: sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==} + engines: {node: '>=12'} + cpu: [x64] + os: [netbsd] + + '@esbuild/openbsd-x64@0.21.5': + resolution: {integrity: sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==} + engines: {node: '>=12'} + cpu: [x64] + os: [openbsd] + + '@esbuild/sunos-x64@0.21.5': + resolution: {integrity: sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==} + engines: {node: '>=12'} + cpu: [x64] + os: [sunos] + + '@esbuild/win32-arm64@0.21.5': + resolution: {integrity: sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==} + engines: {node: '>=12'} + cpu: [arm64] + os: [win32] + + '@esbuild/win32-ia32@0.21.5': + resolution: {integrity: sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==} + engines: {node: '>=12'} + cpu: [ia32] + os: [win32] + + '@esbuild/win32-x64@0.21.5': + resolution: {integrity: sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==} + engines: {node: '>=12'} + cpu: [x64] + os: [win32] + + '@eslint-community/eslint-utils@4.9.0': + resolution: {integrity: sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + + '@eslint-community/regexpp@4.12.2': + resolution: {integrity: sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==} + engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0} + + '@eslint/config-array@0.21.1': + resolution: {integrity: sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/config-helpers@0.4.2': + resolution: {integrity: sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/core@0.17.0': + resolution: {integrity: sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/eslintrc@3.3.1': + resolution: {integrity: sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/js@9.39.1': + resolution: {integrity: sha512-S26Stp4zCy88tH94QbBv3XCuzRQiZ9yXofEILmglYTh/Ug/a9/umqvgFtYBAo3Lp0nsI/5/qH1CCrbdK3AP1Tw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/object-schema@2.1.7': + resolution: {integrity: sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/plugin-kit@0.4.1': + resolution: {integrity: sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@humanfs/core@0.19.1': + resolution: {integrity: sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==} + engines: {node: '>=18.18.0'} + + '@humanfs/node@0.16.7': + resolution: {integrity: sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==} + engines: {node: '>=18.18.0'} + + '@humanwhocodes/module-importer@1.0.1': + resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==} + engines: {node: '>=12.22'} + + '@humanwhocodes/retry@0.4.3': + resolution: {integrity: sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==} + engines: {node: '>=18.18'} + + '@istanbuljs/schema@0.1.3': + resolution: {integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==} + engines: {node: '>=8'} + + '@jest/schemas@29.6.3': + resolution: {integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + '@jridgewell/gen-mapping@0.3.13': + resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==} + + '@jridgewell/resolve-uri@3.1.2': + resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==} + engines: {node: '>=6.0.0'} + + '@jridgewell/sourcemap-codec@1.5.5': + resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==} + + '@jridgewell/trace-mapping@0.3.31': + resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==} + + '@nodelib/fs.scandir@2.1.5': + resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==} + engines: {node: '>= 8'} + + '@nodelib/fs.stat@2.0.5': + resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==} + engines: {node: '>= 8'} + + '@nodelib/fs.walk@1.2.8': + resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==} + engines: {node: '>= 8'} + + '@rollup/rollup-android-arm-eabi@4.52.5': + resolution: {integrity: sha512-8c1vW4ocv3UOMp9K+gToY5zL2XiiVw3k7f1ksf4yO1FlDFQ1C2u72iACFnSOceJFsWskc2WZNqeRhFRPzv+wtQ==} + cpu: [arm] + os: [android] + + '@rollup/rollup-android-arm64@4.52.5': + resolution: {integrity: sha512-mQGfsIEFcu21mvqkEKKu2dYmtuSZOBMmAl5CFlPGLY94Vlcm+zWApK7F/eocsNzp8tKmbeBP8yXyAbx0XHsFNA==} + cpu: [arm64] + os: [android] + + '@rollup/rollup-darwin-arm64@4.52.5': + resolution: {integrity: sha512-takF3CR71mCAGA+v794QUZ0b6ZSrgJkArC+gUiG6LB6TQty9T0Mqh3m2ImRBOxS2IeYBo4lKWIieSvnEk2OQWA==} + cpu: [arm64] + os: [darwin] + + '@rollup/rollup-darwin-x64@4.52.5': + resolution: {integrity: sha512-W901Pla8Ya95WpxDn//VF9K9u2JbocwV/v75TE0YIHNTbhqUTv9w4VuQ9MaWlNOkkEfFwkdNhXgcLqPSmHy0fA==} + cpu: [x64] + os: [darwin] + + '@rollup/rollup-freebsd-arm64@4.52.5': + resolution: {integrity: sha512-QofO7i7JycsYOWxe0GFqhLmF6l1TqBswJMvICnRUjqCx8b47MTo46W8AoeQwiokAx3zVryVnxtBMcGcnX12LvA==} + cpu: [arm64] + os: [freebsd] + + '@rollup/rollup-freebsd-x64@4.52.5': + resolution: {integrity: sha512-jr21b/99ew8ujZubPo9skbrItHEIE50WdV86cdSoRkKtmWa+DDr6fu2c/xyRT0F/WazZpam6kk7IHBerSL7LDQ==} + cpu: [x64] + os: [freebsd] + + '@rollup/rollup-linux-arm-gnueabihf@4.52.5': + resolution: {integrity: sha512-PsNAbcyv9CcecAUagQefwX8fQn9LQ4nZkpDboBOttmyffnInRy8R8dSg6hxxl2Re5QhHBf6FYIDhIj5v982ATQ==} + cpu: [arm] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-arm-musleabihf@4.52.5': + resolution: {integrity: sha512-Fw4tysRutyQc/wwkmcyoqFtJhh0u31K+Q6jYjeicsGJJ7bbEq8LwPWV/w0cnzOqR2m694/Af6hpFayLJZkG2VQ==} + cpu: [arm] + os: [linux] + libc: [musl] + + '@rollup/rollup-linux-arm64-gnu@4.52.5': + resolution: {integrity: sha512-a+3wVnAYdQClOTlyapKmyI6BLPAFYs0JM8HRpgYZQO02rMR09ZcV9LbQB+NL6sljzG38869YqThrRnfPMCDtZg==} + cpu: [arm64] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-arm64-musl@4.52.5': + resolution: {integrity: sha512-AvttBOMwO9Pcuuf7m9PkC1PUIKsfaAJ4AYhy944qeTJgQOqJYJ9oVl2nYgY7Rk0mkbsuOpCAYSs6wLYB2Xiw0Q==} + cpu: [arm64] + os: [linux] + libc: [musl] + + '@rollup/rollup-linux-loong64-gnu@4.52.5': + resolution: {integrity: sha512-DkDk8pmXQV2wVrF6oq5tONK6UHLz/XcEVow4JTTerdeV1uqPeHxwcg7aFsfnSm9L+OO8WJsWotKM2JJPMWrQtA==} + cpu: [loong64] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-ppc64-gnu@4.52.5': + resolution: {integrity: sha512-W/b9ZN/U9+hPQVvlGwjzi+Wy4xdoH2I8EjaCkMvzpI7wJUs8sWJ03Rq96jRnHkSrcHTpQe8h5Tg3ZzUPGauvAw==} + cpu: [ppc64] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-riscv64-gnu@4.52.5': + resolution: {integrity: sha512-sjQLr9BW7R/ZiXnQiWPkErNfLMkkWIoCz7YMn27HldKsADEKa5WYdobaa1hmN6slu9oWQbB6/jFpJ+P2IkVrmw==} + cpu: [riscv64] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-riscv64-musl@4.52.5': + resolution: {integrity: sha512-hq3jU/kGyjXWTvAh2awn8oHroCbrPm8JqM7RUpKjalIRWWXE01CQOf/tUNWNHjmbMHg/hmNCwc/Pz3k1T/j/Lg==} + cpu: [riscv64] + os: [linux] + libc: [musl] + + '@rollup/rollup-linux-s390x-gnu@4.52.5': + resolution: {integrity: sha512-gn8kHOrku8D4NGHMK1Y7NA7INQTRdVOntt1OCYypZPRt6skGbddska44K8iocdpxHTMMNui5oH4elPH4QOLrFQ==} + cpu: [s390x] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-x64-gnu@4.52.5': + resolution: {integrity: sha512-hXGLYpdhiNElzN770+H2nlx+jRog8TyynpTVzdlc6bndktjKWyZyiCsuDAlpd+j+W+WNqfcyAWz9HxxIGfZm1Q==} + cpu: [x64] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-x64-musl@4.52.5': + resolution: {integrity: sha512-arCGIcuNKjBoKAXD+y7XomR9gY6Mw7HnFBv5Rw7wQRvwYLR7gBAgV7Mb2QTyjXfTveBNFAtPt46/36vV9STLNg==} + cpu: [x64] + os: [linux] + libc: [musl] + + '@rollup/rollup-openharmony-arm64@4.52.5': + resolution: {integrity: sha512-QoFqB6+/9Rly/RiPjaomPLmR/13cgkIGfA40LHly9zcH1S0bN2HVFYk3a1eAyHQyjs3ZJYlXvIGtcCs5tko9Cw==} + cpu: [arm64] + os: [openharmony] + + '@rollup/rollup-win32-arm64-msvc@4.52.5': + resolution: {integrity: sha512-w0cDWVR6MlTstla1cIfOGyl8+qb93FlAVutcor14Gf5Md5ap5ySfQ7R9S/NjNaMLSFdUnKGEasmVnu3lCMqB7w==} + cpu: [arm64] + os: [win32] + + '@rollup/rollup-win32-ia32-msvc@4.52.5': + resolution: {integrity: sha512-Aufdpzp7DpOTULJCuvzqcItSGDH73pF3ko/f+ckJhxQyHtp67rHw3HMNxoIdDMUITJESNE6a8uh4Lo4SLouOUg==} + cpu: [ia32] + os: [win32] + + '@rollup/rollup-win32-x64-gnu@4.52.5': + resolution: {integrity: sha512-UGBUGPFp1vkj6p8wCRraqNhqwX/4kNQPS57BCFc8wYh0g94iVIW33wJtQAx3G7vrjjNtRaxiMUylM0ktp/TRSQ==} + cpu: [x64] + os: [win32] + + '@rollup/rollup-win32-x64-msvc@4.52.5': + resolution: {integrity: sha512-TAcgQh2sSkykPRWLrdyy2AiceMckNf5loITqXxFI5VuQjS5tSuw3WlwdN8qv8vzjLAUTvYaH/mVjSFpbkFbpTg==} + cpu: [x64] + os: [win32] + + '@sinclair/typebox@0.27.8': + resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==} + + '@types/chai-subset@1.3.6': + resolution: {integrity: sha512-m8lERkkQj+uek18hXOZuec3W/fCRTrU4hrnXjH3qhHy96ytuPaPiWGgu7sJb7tZxZonO75vYAjCvpe/e4VUwRw==} + peerDependencies: + '@types/chai': <5.2.0 + + '@types/chai@4.3.20': + resolution: {integrity: sha512-/pC9HAB5I/xMlc5FP77qjCnI16ChlJfW0tGa0IUcFn38VJrTV6DeZ60NU5KZBtaOZqjdpwTWohz5HU1RrhiYxQ==} + + '@types/estree@1.0.8': + resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==} + + '@types/istanbul-lib-coverage@2.0.6': + resolution: {integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==} + + '@types/json-schema@7.0.15': + resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==} + + '@types/lodash@4.17.20': + resolution: {integrity: sha512-H3MHACvFUEiujabxhaI/ImO6gUrd8oOurg7LQtS7mbwIXA/cUqWrvBsaeJ23aZEPk1TAYkurjfMbSELfoCXlGA==} + + '@types/node@20.19.24': + resolution: {integrity: sha512-FE5u0ezmi6y9OZEzlJfg37mqqf6ZDSF2V/NLjUyGrR9uTZ7Sb9F7bLNZ03S4XVUNRWGA7Ck4c1kK+YnuWjl+DA==} + + '@typescript-eslint/eslint-plugin@8.46.3': + resolution: {integrity: sha512-sbaQ27XBUopBkRiuY/P9sWGOWUW4rl8fDoHIUmLpZd8uldsTyB4/Zg6bWTegPoTLnKj9Hqgn3QD6cjPNB32Odw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + '@typescript-eslint/parser': ^8.46.3 + eslint: ^8.57.0 || ^9.0.0 + typescript: '>=4.8.4 <6.0.0' + + '@typescript-eslint/parser@8.46.3': + resolution: {integrity: sha512-6m1I5RmHBGTnUGS113G04DMu3CpSdxCAU/UvtjNWL4Nuf3MW9tQhiJqRlHzChIkhy6kZSAQmc+I1bcGjE3yNKg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 + typescript: '>=4.8.4 <6.0.0' + + '@typescript-eslint/project-service@8.46.3': + resolution: {integrity: sha512-Fz8yFXsp2wDFeUElO88S9n4w1I4CWDTXDqDr9gYvZgUpwXQqmZBr9+NTTql5R3J7+hrJZPdpiWaB9VNhAKYLuQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '>=4.8.4 <6.0.0' + + '@typescript-eslint/scope-manager@8.46.3': + resolution: {integrity: sha512-FCi7Y1zgrmxp3DfWfr+3m9ansUUFoy8dkEdeQSgA9gbm8DaHYvZCdkFRQrtKiedFf3Ha6VmoqoAaP68+i+22kg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@typescript-eslint/tsconfig-utils@8.46.3': + resolution: {integrity: sha512-GLupljMniHNIROP0zE7nCcybptolcH8QZfXOpCfhQDAdwJ/ZTlcaBOYebSOZotpti/3HrHSw7D3PZm75gYFsOA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '>=4.8.4 <6.0.0' + + '@typescript-eslint/type-utils@8.46.3': + resolution: {integrity: sha512-ZPCADbr+qfz3aiTTYNNkCbUt+cjNwI/5McyANNrFBpVxPt7GqpEYz5ZfdwuFyGUnJ9FdDXbGODUu6iRCI6XRXw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 + typescript: '>=4.8.4 <6.0.0' + + '@typescript-eslint/types@8.46.3': + resolution: {integrity: sha512-G7Ok9WN/ggW7e/tOf8TQYMaxgID3Iujn231hfi0Pc7ZheztIJVpO44ekY00b7akqc6nZcvregk0Jpah3kep6hA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@typescript-eslint/typescript-estree@8.46.3': + resolution: {integrity: sha512-f/NvtRjOm80BtNM5OQtlaBdM5BRFUv7gf381j9wygDNL+qOYSNOgtQ/DCndiYi80iIOv76QqaTmp4fa9hwI0OA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '>=4.8.4 <6.0.0' + + '@typescript-eslint/utils@8.46.3': + resolution: {integrity: sha512-VXw7qmdkucEx9WkmR3ld/u6VhRyKeiF1uxWwCy/iuNfokjJ7VhsgLSOTjsol8BunSw190zABzpwdNsze2Kpo4g==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 + typescript: '>=4.8.4 <6.0.0' + + '@typescript-eslint/visitor-keys@8.46.3': + resolution: {integrity: sha512-uk574k8IU0rOF/AjniX8qbLSGURJVUCeM5e4MIMKBFFi8weeiLrG1fyQejyLXQpRZbU/1BuQasleV/RfHC3hHg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@vitest/coverage-v8@0.34.6': + resolution: {integrity: sha512-fivy/OK2d/EsJFoEoxHFEnNGTg+MmdZBAVK9Ka4qhXR2K3J0DS08vcGVwzDtXSuUMabLv4KtPcpSKkcMXFDViw==} + peerDependencies: + vitest: '>=0.32.0 <1' + + '@vitest/expect@0.34.6': + resolution: {integrity: sha512-QUzKpUQRc1qC7qdGo7rMK3AkETI7w18gTCUrsNnyjjJKYiuUB9+TQK3QnR1unhCnWRC0AbKv2omLGQDF/mIjOw==} + + '@vitest/runner@0.34.6': + resolution: {integrity: sha512-1CUQgtJSLF47NnhN+F9X2ycxUP0kLHQ/JWvNHbeBfwW8CzEGgeskzNnHDyv1ieKTltuR6sdIHV+nmR6kPxQqzQ==} + + '@vitest/snapshot@0.34.6': + resolution: {integrity: sha512-B3OZqYn6k4VaN011D+ve+AA4whM4QkcwcrwaKwAbyyvS/NB1hCWjFIBQxAQQSQir9/RtyAAGuq+4RJmbn2dH4w==} + + '@vitest/spy@0.34.6': + resolution: {integrity: sha512-xaCvneSaeBw/cz8ySmF7ZwGvL0lBjfvqc1LpQ/vcdHEvpLn3Ff1vAvjw+CoGn0802l++5L/pxb7whwcWAw+DUQ==} + + '@vitest/utils@0.34.6': + resolution: {integrity: sha512-IG5aDD8S6zlvloDsnzHw0Ut5xczlF+kv2BOTo+iXfPr54Yhi5qbVOgGB1hZaVq4iJ4C/MZ2J0y15IlsV/ZcI0A==} + + acorn-jsx@5.3.2: + resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==} + peerDependencies: + acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 + + acorn-walk@8.3.4: + resolution: {integrity: sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==} + engines: {node: '>=0.4.0'} + + acorn@8.15.0: + resolution: {integrity: sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==} + engines: {node: '>=0.4.0'} + hasBin: true + + ajv@6.12.6: + resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==} + + ansi-styles@4.3.0: + resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} + engines: {node: '>=8'} + + ansi-styles@5.2.0: + resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==} + engines: {node: '>=10'} + + argparse@2.0.1: + resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} + + assertion-error@1.1.0: + resolution: {integrity: sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==} + + asynckit@0.4.0: + resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} + + axios@1.13.2: + resolution: {integrity: sha512-VPk9ebNqPcy5lRGuSlKx752IlDatOjT9paPlm8A7yOuW2Fbvp4X3JznJtT4f0GzGLLiWE9W8onz51SqLYwzGaA==} + + balanced-match@1.0.2: + resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} + + brace-expansion@1.1.12: + resolution: {integrity: sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==} + + brace-expansion@2.0.2: + resolution: {integrity: sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==} + + braces@3.0.3: + resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==} + engines: {node: '>=8'} + + cac@6.7.14: + resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==} + engines: {node: '>=8'} + + call-bind-apply-helpers@1.0.2: + resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==} + engines: {node: '>= 0.4'} + + callsites@3.1.0: + resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} + engines: {node: '>=6'} + + chai@4.5.0: + resolution: {integrity: sha512-RITGBfijLkBddZvnn8jdqoTypxvqbOLYQkGGxXzeFjVHvudaPw0HNFD9x928/eUwYWd2dPCugVqspGALTZZQKw==} + engines: {node: '>=4'} + + chalk@4.1.2: + resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} + engines: {node: '>=10'} + + check-error@1.0.3: + resolution: {integrity: sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==} + + color-convert@2.0.1: + resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==} + engines: {node: '>=7.0.0'} + + color-name@1.1.4: + resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} + + combined-stream@1.0.8: + resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} + engines: {node: '>= 0.8'} + + concat-map@0.0.1: + resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} + + confbox@0.1.8: + resolution: {integrity: sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==} + + convert-source-map@2.0.0: + resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} + + cross-spawn@7.0.6: + resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==} + engines: {node: '>= 8'} + + debug@4.4.3: + resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==} + engines: {node: '>=6.0'} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true + + deep-eql@4.1.4: + resolution: {integrity: sha512-SUwdGfqdKOwxCPeVYjwSyRpJ7Z+fhpwIAtmCUdZIWZ/YP5R9WAsyuSgpLVDi9bjWoN2LXHNss/dk3urXtdQxGg==} + engines: {node: '>=6'} + + deep-is@0.1.4: + resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==} + + delayed-stream@1.0.0: + resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==} + engines: {node: '>=0.4.0'} + + diff-sequences@29.6.3: + resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + dunder-proto@1.0.1: + resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==} + engines: {node: '>= 0.4'} + + es-define-property@1.0.1: + resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==} + engines: {node: '>= 0.4'} + + es-errors@1.3.0: + resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==} + engines: {node: '>= 0.4'} + + es-object-atoms@1.1.1: + resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==} + engines: {node: '>= 0.4'} + + es-set-tostringtag@2.1.0: + resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==} + engines: {node: '>= 0.4'} + + esbuild@0.21.5: + resolution: {integrity: sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==} + engines: {node: '>=12'} + hasBin: true + + escape-string-regexp@4.0.0: + resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==} + engines: {node: '>=10'} + + eslint-scope@8.4.0: + resolution: {integrity: sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + eslint-visitor-keys@3.4.3: + resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + + eslint-visitor-keys@4.2.1: + resolution: {integrity: sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + eslint@9.39.1: + resolution: {integrity: sha512-BhHmn2yNOFA9H9JmmIVKJmd288g9hrVRDkdoIgRCRuSySRUHH7r/DI6aAXW9T1WwUuY3DFgrcaqB+deURBLR5g==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + hasBin: true + peerDependencies: + jiti: '*' + peerDependenciesMeta: + jiti: + optional: true + + espree@10.4.0: + resolution: {integrity: sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + esquery@1.6.0: + resolution: {integrity: sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==} + engines: {node: '>=0.10'} + + esrecurse@4.3.0: + resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==} + engines: {node: '>=4.0'} + + estraverse@5.3.0: + resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==} + engines: {node: '>=4.0'} + + esutils@2.0.3: + resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==} + engines: {node: '>=0.10.0'} + + fast-deep-equal@3.1.3: + resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} + + fast-glob@3.3.3: + resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==} + engines: {node: '>=8.6.0'} + + fast-json-stable-stringify@2.1.0: + resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==} + + fast-levenshtein@2.0.6: + resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==} + + fastq@1.19.1: + resolution: {integrity: sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==} + + file-entry-cache@8.0.0: + resolution: {integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==} + engines: {node: '>=16.0.0'} + + fill-range@7.1.1: + resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==} + engines: {node: '>=8'} + + find-up@5.0.0: + resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==} + engines: {node: '>=10'} + + flat-cache@4.0.1: + resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==} + engines: {node: '>=16'} + + flatted@3.3.3: + resolution: {integrity: sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==} + + follow-redirects@1.15.11: + resolution: {integrity: sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==} + engines: {node: '>=4.0'} + peerDependencies: + debug: '*' + peerDependenciesMeta: + debug: + optional: true + + form-data@4.0.4: + resolution: {integrity: sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==} + engines: {node: '>= 6'} + + fs.realpath@1.0.0: + resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==} + + fsevents@2.3.3: + resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==} + engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} + os: [darwin] + + function-bind@1.1.2: + resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} + + get-func-name@2.0.2: + resolution: {integrity: sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==} + + get-intrinsic@1.3.0: + resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==} + engines: {node: '>= 0.4'} + + get-proto@1.0.1: + resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==} + engines: {node: '>= 0.4'} + + glob-parent@5.1.2: + resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==} + engines: {node: '>= 6'} + + glob-parent@6.0.2: + resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==} + engines: {node: '>=10.13.0'} + + glob@7.2.3: + resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==} + deprecated: Glob versions prior to v9 are no longer supported + + globals@14.0.0: + resolution: {integrity: sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==} + engines: {node: '>=18'} + + gopd@1.2.0: + resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==} + engines: {node: '>= 0.4'} + + graphemer@1.4.0: + resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==} + + has-flag@4.0.0: + resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} + engines: {node: '>=8'} + + has-symbols@1.1.0: + resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==} + engines: {node: '>= 0.4'} + + has-tostringtag@1.0.2: + resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==} + engines: {node: '>= 0.4'} + + hasown@2.0.2: + resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} + engines: {node: '>= 0.4'} + + html-escaper@2.0.2: + resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==} + + ignore@5.3.2: + resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==} + engines: {node: '>= 4'} + + ignore@7.0.5: + resolution: {integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==} + engines: {node: '>= 4'} + + import-fresh@3.3.1: + resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==} + engines: {node: '>=6'} + + imurmurhash@0.1.4: + resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==} + engines: {node: '>=0.8.19'} + + inflight@1.0.6: + resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==} + deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful. + + inherits@2.0.4: + resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} + + is-extglob@2.1.1: + resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} + engines: {node: '>=0.10.0'} + + is-glob@4.0.3: + resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} + engines: {node: '>=0.10.0'} + + is-number@7.0.0: + resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} + engines: {node: '>=0.12.0'} + + isexe@2.0.0: + resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} + + istanbul-lib-coverage@3.2.2: + resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==} + engines: {node: '>=8'} + + istanbul-lib-report@3.0.1: + resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==} + engines: {node: '>=10'} + + istanbul-lib-source-maps@4.0.1: + resolution: {integrity: sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==} + engines: {node: '>=10'} + + istanbul-reports@3.2.0: + resolution: {integrity: sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==} + engines: {node: '>=8'} + + js-yaml@4.1.0: + resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==} + hasBin: true + + json-buffer@3.0.1: + resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==} + + json-schema-traverse@0.4.1: + resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==} + + json-stable-stringify-without-jsonify@1.0.1: + resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==} + + keyv@4.5.4: + resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==} + + levn@0.4.1: + resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==} + engines: {node: '>= 0.8.0'} + + local-pkg@0.4.3: + resolution: {integrity: sha512-SFppqq5p42fe2qcZQqqEOiVRXl+WCP1MdT6k7BDEW1j++sp5fIY+/fdRQitvKgB5BrBcmrs5m/L0v2FrU5MY1g==} + engines: {node: '>=14'} + + locate-path@6.0.0: + resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==} + engines: {node: '>=10'} + + lodash.merge@4.6.2: + resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==} + + loupe@2.3.7: + resolution: {integrity: sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==} + + magic-string@0.30.21: + resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==} + + make-dir@4.0.0: + resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==} + engines: {node: '>=10'} + + math-intrinsics@1.1.0: + resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==} + engines: {node: '>= 0.4'} + + merge2@1.4.1: + resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==} + engines: {node: '>= 8'} + + micromatch@4.0.8: + resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==} + engines: {node: '>=8.6'} + + mime-db@1.52.0: + resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==} + engines: {node: '>= 0.6'} + + mime-types@2.1.35: + resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==} + engines: {node: '>= 0.6'} + + minimatch@3.1.2: + resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==} + + minimatch@9.0.5: + resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==} + engines: {node: '>=16 || 14 >=14.17'} + + mlly@1.8.0: + resolution: {integrity: sha512-l8D9ODSRWLe2KHJSifWGwBqpTZXIXTeo8mlKjY+E2HAakaTeNpqAyBZ8GSqLzHgw4XmHmC8whvpjJNMbFZN7/g==} + + ms@2.1.3: + resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} + + nanoid@3.3.11: + resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==} + engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1} + hasBin: true + + natural-compare@1.4.0: + resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==} + + once@1.4.0: + resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} + + optionator@0.9.4: + resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==} + engines: {node: '>= 0.8.0'} + + p-limit@3.1.0: + resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==} + engines: {node: '>=10'} + + p-limit@4.0.0: + resolution: {integrity: sha512-5b0R4txpzjPWVw/cXXUResoD4hb6U/x9BH08L7nw+GN1sezDzPdxeRvpc9c433fZhBan/wusjbCsqwqm4EIBIQ==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + + p-locate@5.0.0: + resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==} + engines: {node: '>=10'} + + parent-module@1.0.1: + resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==} + engines: {node: '>=6'} + + path-exists@4.0.0: + resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} + engines: {node: '>=8'} + + path-is-absolute@1.0.1: + resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==} + engines: {node: '>=0.10.0'} + + path-key@3.1.1: + resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} + engines: {node: '>=8'} + + pathe@1.1.2: + resolution: {integrity: sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==} + + pathe@2.0.3: + resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==} + + pathval@1.1.1: + resolution: {integrity: sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==} + + picocolors@1.1.1: + resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==} + + picomatch@2.3.1: + resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==} + engines: {node: '>=8.6'} + + pkg-types@1.3.1: + resolution: {integrity: sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==} + + postcss@8.5.6: + resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==} + engines: {node: ^10 || ^12 || >=14} + + prelude-ls@1.2.1: + resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==} + engines: {node: '>= 0.8.0'} + + pretty-format@29.7.0: + resolution: {integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + proxy-from-env@1.1.0: + resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==} + + punycode@2.3.1: + resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==} + engines: {node: '>=6'} + + queue-microtask@1.2.3: + resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} + + react-is@18.3.1: + resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==} + + resolve-from@4.0.0: + resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==} + engines: {node: '>=4'} + + reusify@1.1.0: + resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==} + engines: {iojs: '>=1.0.0', node: '>=0.10.0'} + + rollup@4.52.5: + resolution: {integrity: sha512-3GuObel8h7Kqdjt0gxkEzaifHTqLVW56Y/bjN7PSQtkKr0w3V/QYSdt6QWYtd7A1xUtYQigtdUfgj1RvWVtorw==} + engines: {node: '>=18.0.0', npm: '>=8.0.0'} + hasBin: true + + run-parallel@1.2.0: + resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==} + + semver@7.7.3: + resolution: {integrity: sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==} + engines: {node: '>=10'} + hasBin: true + + shebang-command@2.0.0: + resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==} + engines: {node: '>=8'} + + shebang-regex@3.0.0: + resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} + engines: {node: '>=8'} + + siginfo@2.0.0: + resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==} + + source-map-js@1.2.1: + resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==} + engines: {node: '>=0.10.0'} + + source-map@0.6.1: + resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==} + engines: {node: '>=0.10.0'} + + stackback@0.0.2: + resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==} + + std-env@3.10.0: + resolution: {integrity: sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==} + + strip-json-comments@3.1.1: + resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==} + engines: {node: '>=8'} + + strip-literal@1.3.0: + resolution: {integrity: sha512-PugKzOsyXpArk0yWmUwqOZecSO0GH0bPoctLcqNDH9J04pVW3lflYE0ujElBGTloevcxF5MofAOZ7C5l2b+wLg==} + + supports-color@7.2.0: + resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} + engines: {node: '>=8'} + + test-exclude@6.0.0: + resolution: {integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==} + engines: {node: '>=8'} + + tinybench@2.9.0: + resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==} + + tinypool@0.7.0: + resolution: {integrity: sha512-zSYNUlYSMhJ6Zdou4cJwo/p7w5nmAH17GRfU/ui3ctvjXFErXXkruT4MWW6poDeXgCaIBlGLrfU6TbTXxyGMww==} + engines: {node: '>=14.0.0'} + + tinyspy@2.2.1: + resolution: {integrity: sha512-KYad6Vy5VDWV4GH3fjpseMQ/XU2BhIYP7Vzd0LG44qRWm/Yt2WCOTicFdvmgo6gWaqooMQCawTtILVQJupKu7A==} + engines: {node: '>=14.0.0'} + + to-regex-range@5.0.1: + resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==} + engines: {node: '>=8.0'} + + ts-api-utils@2.1.0: + resolution: {integrity: sha512-CUgTZL1irw8u29bzrOD/nH85jqyc74D6SshFgujOIA7osm2Rz7dYH77agkx7H4FBNxDq7Cjf+IjaX/8zwFW+ZQ==} + engines: {node: '>=18.12'} + peerDependencies: + typescript: '>=4.8.4' + + type-check@0.4.0: + resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==} + engines: {node: '>= 0.8.0'} + + type-detect@4.1.0: + resolution: {integrity: sha512-Acylog8/luQ8L7il+geoSxhEkazvkslg7PSNKOX59mbB9cOveP5aq9h74Y7YU8yDpJwetzQQrfIwtf4Wp4LKcw==} + engines: {node: '>=4'} + + typescript@5.9.3: + resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==} + engines: {node: '>=14.17'} + hasBin: true + + ufo@1.6.1: + resolution: {integrity: sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA==} + + undici-types@6.21.0: + resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==} + + uri-js@4.4.1: + resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} + + v8-to-istanbul@9.3.0: + resolution: {integrity: sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==} + engines: {node: '>=10.12.0'} + + vite-node@0.34.6: + resolution: {integrity: sha512-nlBMJ9x6n7/Amaz6F3zJ97EBwR2FkzhBRxF5e+jE6LA3yi6Wtc2lyTij1OnDMIr34v5g/tVQtsVAzhT0jc5ygA==} + engines: {node: '>=v14.18.0'} + hasBin: true + + vite@5.4.21: + resolution: {integrity: sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==} + engines: {node: ^18.0.0 || >=20.0.0} + hasBin: true + peerDependencies: + '@types/node': ^18.0.0 || >=20.0.0 + less: '*' + lightningcss: ^1.21.0 + sass: '*' + sass-embedded: '*' + stylus: '*' + sugarss: '*' + terser: ^5.4.0 + peerDependenciesMeta: + '@types/node': + optional: true + less: + optional: true + lightningcss: + optional: true + sass: + optional: true + sass-embedded: + optional: true + stylus: + optional: true + sugarss: + optional: true + terser: + optional: true + + vitest@0.34.6: + resolution: {integrity: sha512-+5CALsOvbNKnS+ZHMXtuUC7nL8/7F1F2DnHGjSsszX8zCjWSSviphCb/NuS9Nzf4Q03KyyDRBAXhF/8lffME4Q==} + engines: {node: '>=v14.18.0'} + hasBin: true + peerDependencies: + '@edge-runtime/vm': '*' + '@vitest/browser': '*' + '@vitest/ui': '*' + happy-dom: '*' + jsdom: '*' + playwright: '*' + safaridriver: '*' + webdriverio: '*' + peerDependenciesMeta: + '@edge-runtime/vm': + optional: true + '@vitest/browser': + optional: true + '@vitest/ui': + optional: true + happy-dom: + optional: true + jsdom: + optional: true + playwright: + optional: true + safaridriver: + optional: true + webdriverio: + optional: true + + which@2.0.2: + resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==} + engines: {node: '>= 8'} + hasBin: true + + why-is-node-running@2.3.0: + resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==} + engines: {node: '>=8'} + hasBin: true + + word-wrap@1.2.5: + resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==} + engines: {node: '>=0.10.0'} + + wrappy@1.0.2: + resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} + + yocto-queue@0.1.0: + resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==} + engines: {node: '>=10'} + + yocto-queue@1.2.1: + resolution: {integrity: sha512-AyeEbWOu/TAXdxlV9wmGcR0+yh2j3vYPGOECcIj2S7MkrLyC7ne+oye2BKTItt0ii2PHk4cDy+95+LshzbXnGg==} + engines: {node: '>=12.20'} + +snapshots: + + '@ampproject/remapping@2.3.0': + dependencies: + '@jridgewell/gen-mapping': 0.3.13 + '@jridgewell/trace-mapping': 0.3.31 + + '@bcoe/v8-coverage@0.2.3': {} + + '@esbuild/aix-ppc64@0.21.5': + optional: true + + '@esbuild/android-arm64@0.21.5': + optional: true + + '@esbuild/android-arm@0.21.5': + optional: true + + '@esbuild/android-x64@0.21.5': + optional: true + + '@esbuild/darwin-arm64@0.21.5': + optional: true + + '@esbuild/darwin-x64@0.21.5': + optional: true + + '@esbuild/freebsd-arm64@0.21.5': + optional: true + + '@esbuild/freebsd-x64@0.21.5': + optional: true + + '@esbuild/linux-arm64@0.21.5': + optional: true + + '@esbuild/linux-arm@0.21.5': + optional: true + + '@esbuild/linux-ia32@0.21.5': + optional: true + + '@esbuild/linux-loong64@0.21.5': + optional: true + + '@esbuild/linux-mips64el@0.21.5': + optional: true + + '@esbuild/linux-ppc64@0.21.5': + optional: true + + '@esbuild/linux-riscv64@0.21.5': + optional: true + + '@esbuild/linux-s390x@0.21.5': + optional: true + + '@esbuild/linux-x64@0.21.5': + optional: true + + '@esbuild/netbsd-x64@0.21.5': + optional: true + + '@esbuild/openbsd-x64@0.21.5': + optional: true + + '@esbuild/sunos-x64@0.21.5': + optional: true + + '@esbuild/win32-arm64@0.21.5': + optional: true + + '@esbuild/win32-ia32@0.21.5': + optional: true + + '@esbuild/win32-x64@0.21.5': + optional: true + + '@eslint-community/eslint-utils@4.9.0(eslint@9.39.1)': + dependencies: + eslint: 9.39.1 + eslint-visitor-keys: 3.4.3 + + '@eslint-community/regexpp@4.12.2': {} + + '@eslint/config-array@0.21.1': + dependencies: + '@eslint/object-schema': 2.1.7 + debug: 4.4.3 + minimatch: 3.1.2 + transitivePeerDependencies: + - supports-color + + '@eslint/config-helpers@0.4.2': + dependencies: + '@eslint/core': 0.17.0 + + '@eslint/core@0.17.0': + dependencies: + '@types/json-schema': 7.0.15 + + '@eslint/eslintrc@3.3.1': + dependencies: + ajv: 6.12.6 + debug: 4.4.3 + espree: 10.4.0 + globals: 14.0.0 + ignore: 5.3.2 + import-fresh: 3.3.1 + js-yaml: 4.1.0 + minimatch: 3.1.2 + strip-json-comments: 3.1.1 + transitivePeerDependencies: + - supports-color + + '@eslint/js@9.39.1': {} + + '@eslint/object-schema@2.1.7': {} + + '@eslint/plugin-kit@0.4.1': + dependencies: + '@eslint/core': 0.17.0 + levn: 0.4.1 + + '@humanfs/core@0.19.1': {} + + '@humanfs/node@0.16.7': + dependencies: + '@humanfs/core': 0.19.1 + '@humanwhocodes/retry': 0.4.3 + + '@humanwhocodes/module-importer@1.0.1': {} + + '@humanwhocodes/retry@0.4.3': {} + + '@istanbuljs/schema@0.1.3': {} + + '@jest/schemas@29.6.3': + dependencies: + '@sinclair/typebox': 0.27.8 + + '@jridgewell/gen-mapping@0.3.13': + dependencies: + '@jridgewell/sourcemap-codec': 1.5.5 + '@jridgewell/trace-mapping': 0.3.31 + + '@jridgewell/resolve-uri@3.1.2': {} + + '@jridgewell/sourcemap-codec@1.5.5': {} + + '@jridgewell/trace-mapping@0.3.31': + dependencies: + '@jridgewell/resolve-uri': 3.1.2 + '@jridgewell/sourcemap-codec': 1.5.5 + + '@nodelib/fs.scandir@2.1.5': + dependencies: + '@nodelib/fs.stat': 2.0.5 + run-parallel: 1.2.0 + + '@nodelib/fs.stat@2.0.5': {} + + '@nodelib/fs.walk@1.2.8': + dependencies: + '@nodelib/fs.scandir': 2.1.5 + fastq: 1.19.1 + + '@rollup/rollup-android-arm-eabi@4.52.5': + optional: true + + '@rollup/rollup-android-arm64@4.52.5': + optional: true + + '@rollup/rollup-darwin-arm64@4.52.5': + optional: true + + '@rollup/rollup-darwin-x64@4.52.5': + optional: true + + '@rollup/rollup-freebsd-arm64@4.52.5': + optional: true + + '@rollup/rollup-freebsd-x64@4.52.5': + optional: true + + '@rollup/rollup-linux-arm-gnueabihf@4.52.5': + optional: true + + '@rollup/rollup-linux-arm-musleabihf@4.52.5': + optional: true + + '@rollup/rollup-linux-arm64-gnu@4.52.5': + optional: true + + '@rollup/rollup-linux-arm64-musl@4.52.5': + optional: true + + '@rollup/rollup-linux-loong64-gnu@4.52.5': + optional: true + + '@rollup/rollup-linux-ppc64-gnu@4.52.5': + optional: true + + '@rollup/rollup-linux-riscv64-gnu@4.52.5': + optional: true + + '@rollup/rollup-linux-riscv64-musl@4.52.5': + optional: true + + '@rollup/rollup-linux-s390x-gnu@4.52.5': + optional: true + + '@rollup/rollup-linux-x64-gnu@4.52.5': + optional: true + + '@rollup/rollup-linux-x64-musl@4.52.5': + optional: true + + '@rollup/rollup-openharmony-arm64@4.52.5': + optional: true + + '@rollup/rollup-win32-arm64-msvc@4.52.5': + optional: true + + '@rollup/rollup-win32-ia32-msvc@4.52.5': + optional: true + + '@rollup/rollup-win32-x64-gnu@4.52.5': + optional: true + + '@rollup/rollup-win32-x64-msvc@4.52.5': + optional: true + + '@sinclair/typebox@0.27.8': {} + + '@types/chai-subset@1.3.6(@types/chai@4.3.20)': + dependencies: + '@types/chai': 4.3.20 + + '@types/chai@4.3.20': {} + + '@types/estree@1.0.8': {} + + '@types/istanbul-lib-coverage@2.0.6': {} + + '@types/json-schema@7.0.15': {} + + '@types/lodash@4.17.20': {} + + '@types/node@20.19.24': + dependencies: + undici-types: 6.21.0 + + '@typescript-eslint/eslint-plugin@8.46.3(@typescript-eslint/parser@8.46.3(eslint@9.39.1)(typescript@5.9.3))(eslint@9.39.1)(typescript@5.9.3)': + dependencies: + '@eslint-community/regexpp': 4.12.2 + '@typescript-eslint/parser': 8.46.3(eslint@9.39.1)(typescript@5.9.3) + '@typescript-eslint/scope-manager': 8.46.3 + '@typescript-eslint/type-utils': 8.46.3(eslint@9.39.1)(typescript@5.9.3) + '@typescript-eslint/utils': 8.46.3(eslint@9.39.1)(typescript@5.9.3) + '@typescript-eslint/visitor-keys': 8.46.3 + eslint: 9.39.1 + graphemer: 1.4.0 + ignore: 7.0.5 + natural-compare: 1.4.0 + ts-api-utils: 2.1.0(typescript@5.9.3) + typescript: 5.9.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/parser@8.46.3(eslint@9.39.1)(typescript@5.9.3)': + dependencies: + '@typescript-eslint/scope-manager': 8.46.3 + '@typescript-eslint/types': 8.46.3 + '@typescript-eslint/typescript-estree': 8.46.3(typescript@5.9.3) + '@typescript-eslint/visitor-keys': 8.46.3 + debug: 4.4.3 + eslint: 9.39.1 + typescript: 5.9.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/project-service@8.46.3(typescript@5.9.3)': + dependencies: + '@typescript-eslint/tsconfig-utils': 8.46.3(typescript@5.9.3) + '@typescript-eslint/types': 8.46.3 + debug: 4.4.3 + typescript: 5.9.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/scope-manager@8.46.3': + dependencies: + '@typescript-eslint/types': 8.46.3 + '@typescript-eslint/visitor-keys': 8.46.3 + + '@typescript-eslint/tsconfig-utils@8.46.3(typescript@5.9.3)': + dependencies: + typescript: 5.9.3 + + '@typescript-eslint/type-utils@8.46.3(eslint@9.39.1)(typescript@5.9.3)': + dependencies: + '@typescript-eslint/types': 8.46.3 + '@typescript-eslint/typescript-estree': 8.46.3(typescript@5.9.3) + '@typescript-eslint/utils': 8.46.3(eslint@9.39.1)(typescript@5.9.3) + debug: 4.4.3 + eslint: 9.39.1 + ts-api-utils: 2.1.0(typescript@5.9.3) + typescript: 5.9.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/types@8.46.3': {} + + '@typescript-eslint/typescript-estree@8.46.3(typescript@5.9.3)': + dependencies: + '@typescript-eslint/project-service': 8.46.3(typescript@5.9.3) + '@typescript-eslint/tsconfig-utils': 8.46.3(typescript@5.9.3) + '@typescript-eslint/types': 8.46.3 + '@typescript-eslint/visitor-keys': 8.46.3 + debug: 4.4.3 + fast-glob: 3.3.3 + is-glob: 4.0.3 + minimatch: 9.0.5 + semver: 7.7.3 + ts-api-utils: 2.1.0(typescript@5.9.3) + typescript: 5.9.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/utils@8.46.3(eslint@9.39.1)(typescript@5.9.3)': + dependencies: + '@eslint-community/eslint-utils': 4.9.0(eslint@9.39.1) + '@typescript-eslint/scope-manager': 8.46.3 + '@typescript-eslint/types': 8.46.3 + '@typescript-eslint/typescript-estree': 8.46.3(typescript@5.9.3) + eslint: 9.39.1 + typescript: 5.9.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/visitor-keys@8.46.3': + dependencies: + '@typescript-eslint/types': 8.46.3 + eslint-visitor-keys: 4.2.1 + + '@vitest/coverage-v8@0.34.6(vitest@0.34.6)': + dependencies: + '@ampproject/remapping': 2.3.0 + '@bcoe/v8-coverage': 0.2.3 + istanbul-lib-coverage: 3.2.2 + istanbul-lib-report: 3.0.1 + istanbul-lib-source-maps: 4.0.1 + istanbul-reports: 3.2.0 + magic-string: 0.30.21 + picocolors: 1.1.1 + std-env: 3.10.0 + test-exclude: 6.0.0 + v8-to-istanbul: 9.3.0 + vitest: 0.34.6 + transitivePeerDependencies: + - supports-color + + '@vitest/expect@0.34.6': + dependencies: + '@vitest/spy': 0.34.6 + '@vitest/utils': 0.34.6 + chai: 4.5.0 + + '@vitest/runner@0.34.6': + dependencies: + '@vitest/utils': 0.34.6 + p-limit: 4.0.0 + pathe: 1.1.2 + + '@vitest/snapshot@0.34.6': + dependencies: + magic-string: 0.30.21 + pathe: 1.1.2 + pretty-format: 29.7.0 + + '@vitest/spy@0.34.6': + dependencies: + tinyspy: 2.2.1 + + '@vitest/utils@0.34.6': + dependencies: + diff-sequences: 29.6.3 + loupe: 2.3.7 + pretty-format: 29.7.0 + + acorn-jsx@5.3.2(acorn@8.15.0): + dependencies: + acorn: 8.15.0 + + acorn-walk@8.3.4: + dependencies: + acorn: 8.15.0 + + acorn@8.15.0: {} + + ajv@6.12.6: + dependencies: + fast-deep-equal: 3.1.3 + fast-json-stable-stringify: 2.1.0 + json-schema-traverse: 0.4.1 + uri-js: 4.4.1 + + ansi-styles@4.3.0: + dependencies: + color-convert: 2.0.1 + + ansi-styles@5.2.0: {} + + argparse@2.0.1: {} + + assertion-error@1.1.0: {} + + asynckit@0.4.0: {} + + axios@1.13.2: + dependencies: + follow-redirects: 1.15.11 + form-data: 4.0.4 + proxy-from-env: 1.1.0 + transitivePeerDependencies: + - debug + + balanced-match@1.0.2: {} + + brace-expansion@1.1.12: + dependencies: + balanced-match: 1.0.2 + concat-map: 0.0.1 + + brace-expansion@2.0.2: + dependencies: + balanced-match: 1.0.2 + + braces@3.0.3: + dependencies: + fill-range: 7.1.1 + + cac@6.7.14: {} + + call-bind-apply-helpers@1.0.2: + dependencies: + es-errors: 1.3.0 + function-bind: 1.1.2 + + callsites@3.1.0: {} + + chai@4.5.0: + dependencies: + assertion-error: 1.1.0 + check-error: 1.0.3 + deep-eql: 4.1.4 + get-func-name: 2.0.2 + loupe: 2.3.7 + pathval: 1.1.1 + type-detect: 4.1.0 + + chalk@4.1.2: + dependencies: + ansi-styles: 4.3.0 + supports-color: 7.2.0 + + check-error@1.0.3: + dependencies: + get-func-name: 2.0.2 + + color-convert@2.0.1: + dependencies: + color-name: 1.1.4 + + color-name@1.1.4: {} + + combined-stream@1.0.8: + dependencies: + delayed-stream: 1.0.0 + + concat-map@0.0.1: {} + + confbox@0.1.8: {} + + convert-source-map@2.0.0: {} + + cross-spawn@7.0.6: + dependencies: + path-key: 3.1.1 + shebang-command: 2.0.0 + which: 2.0.2 + + debug@4.4.3: + dependencies: + ms: 2.1.3 + + deep-eql@4.1.4: + dependencies: + type-detect: 4.1.0 + + deep-is@0.1.4: {} + + delayed-stream@1.0.0: {} + + diff-sequences@29.6.3: {} + + dunder-proto@1.0.1: + dependencies: + call-bind-apply-helpers: 1.0.2 + es-errors: 1.3.0 + gopd: 1.2.0 + + es-define-property@1.0.1: {} + + es-errors@1.3.0: {} + + es-object-atoms@1.1.1: + dependencies: + es-errors: 1.3.0 + + es-set-tostringtag@2.1.0: + dependencies: + es-errors: 1.3.0 + get-intrinsic: 1.3.0 + has-tostringtag: 1.0.2 + hasown: 2.0.2 + + esbuild@0.21.5: + optionalDependencies: + '@esbuild/aix-ppc64': 0.21.5 + '@esbuild/android-arm': 0.21.5 + '@esbuild/android-arm64': 0.21.5 + '@esbuild/android-x64': 0.21.5 + '@esbuild/darwin-arm64': 0.21.5 + '@esbuild/darwin-x64': 0.21.5 + '@esbuild/freebsd-arm64': 0.21.5 + '@esbuild/freebsd-x64': 0.21.5 + '@esbuild/linux-arm': 0.21.5 + '@esbuild/linux-arm64': 0.21.5 + '@esbuild/linux-ia32': 0.21.5 + '@esbuild/linux-loong64': 0.21.5 + '@esbuild/linux-mips64el': 0.21.5 + '@esbuild/linux-ppc64': 0.21.5 + '@esbuild/linux-riscv64': 0.21.5 + '@esbuild/linux-s390x': 0.21.5 + '@esbuild/linux-x64': 0.21.5 + '@esbuild/netbsd-x64': 0.21.5 + '@esbuild/openbsd-x64': 0.21.5 + '@esbuild/sunos-x64': 0.21.5 + '@esbuild/win32-arm64': 0.21.5 + '@esbuild/win32-ia32': 0.21.5 + '@esbuild/win32-x64': 0.21.5 + + escape-string-regexp@4.0.0: {} + + eslint-scope@8.4.0: + dependencies: + esrecurse: 4.3.0 + estraverse: 5.3.0 + + eslint-visitor-keys@3.4.3: {} + + eslint-visitor-keys@4.2.1: {} + + eslint@9.39.1: + dependencies: + '@eslint-community/eslint-utils': 4.9.0(eslint@9.39.1) + '@eslint-community/regexpp': 4.12.2 + '@eslint/config-array': 0.21.1 + '@eslint/config-helpers': 0.4.2 + '@eslint/core': 0.17.0 + '@eslint/eslintrc': 3.3.1 + '@eslint/js': 9.39.1 + '@eslint/plugin-kit': 0.4.1 + '@humanfs/node': 0.16.7 + '@humanwhocodes/module-importer': 1.0.1 + '@humanwhocodes/retry': 0.4.3 + '@types/estree': 1.0.8 + ajv: 6.12.6 + chalk: 4.1.2 + cross-spawn: 7.0.6 + debug: 4.4.3 + escape-string-regexp: 4.0.0 + eslint-scope: 8.4.0 + eslint-visitor-keys: 4.2.1 + espree: 10.4.0 + esquery: 1.6.0 + esutils: 2.0.3 + fast-deep-equal: 3.1.3 + file-entry-cache: 8.0.0 + find-up: 5.0.0 + glob-parent: 6.0.2 + ignore: 5.3.2 + imurmurhash: 0.1.4 + is-glob: 4.0.3 + json-stable-stringify-without-jsonify: 1.0.1 + lodash.merge: 4.6.2 + minimatch: 3.1.2 + natural-compare: 1.4.0 + optionator: 0.9.4 + transitivePeerDependencies: + - supports-color + + espree@10.4.0: + dependencies: + acorn: 8.15.0 + acorn-jsx: 5.3.2(acorn@8.15.0) + eslint-visitor-keys: 4.2.1 + + esquery@1.6.0: + dependencies: + estraverse: 5.3.0 + + esrecurse@4.3.0: + dependencies: + estraverse: 5.3.0 + + estraverse@5.3.0: {} + + esutils@2.0.3: {} + + fast-deep-equal@3.1.3: {} + + fast-glob@3.3.3: + dependencies: + '@nodelib/fs.stat': 2.0.5 + '@nodelib/fs.walk': 1.2.8 + glob-parent: 5.1.2 + merge2: 1.4.1 + micromatch: 4.0.8 + + fast-json-stable-stringify@2.1.0: {} + + fast-levenshtein@2.0.6: {} + + fastq@1.19.1: + dependencies: + reusify: 1.1.0 + + file-entry-cache@8.0.0: + dependencies: + flat-cache: 4.0.1 + + fill-range@7.1.1: + dependencies: + to-regex-range: 5.0.1 + + find-up@5.0.0: + dependencies: + locate-path: 6.0.0 + path-exists: 4.0.0 + + flat-cache@4.0.1: + dependencies: + flatted: 3.3.3 + keyv: 4.5.4 + + flatted@3.3.3: {} + + follow-redirects@1.15.11: {} + + form-data@4.0.4: + dependencies: + asynckit: 0.4.0 + combined-stream: 1.0.8 + es-set-tostringtag: 2.1.0 + hasown: 2.0.2 + mime-types: 2.1.35 + + fs.realpath@1.0.0: {} + + fsevents@2.3.3: + optional: true + + function-bind@1.1.2: {} + + get-func-name@2.0.2: {} + + get-intrinsic@1.3.0: + dependencies: + call-bind-apply-helpers: 1.0.2 + es-define-property: 1.0.1 + es-errors: 1.3.0 + es-object-atoms: 1.1.1 + function-bind: 1.1.2 + get-proto: 1.0.1 + gopd: 1.2.0 + has-symbols: 1.1.0 + hasown: 2.0.2 + math-intrinsics: 1.1.0 + + get-proto@1.0.1: + dependencies: + dunder-proto: 1.0.1 + es-object-atoms: 1.1.1 + + glob-parent@5.1.2: + dependencies: + is-glob: 4.0.3 + + glob-parent@6.0.2: + dependencies: + is-glob: 4.0.3 + + glob@7.2.3: + dependencies: + fs.realpath: 1.0.0 + inflight: 1.0.6 + inherits: 2.0.4 + minimatch: 3.1.2 + once: 1.4.0 + path-is-absolute: 1.0.1 + + globals@14.0.0: {} + + gopd@1.2.0: {} + + graphemer@1.4.0: {} + + has-flag@4.0.0: {} + + has-symbols@1.1.0: {} + + has-tostringtag@1.0.2: + dependencies: + has-symbols: 1.1.0 + + hasown@2.0.2: + dependencies: + function-bind: 1.1.2 + + html-escaper@2.0.2: {} + + ignore@5.3.2: {} + + ignore@7.0.5: {} + + import-fresh@3.3.1: + dependencies: + parent-module: 1.0.1 + resolve-from: 4.0.0 + + imurmurhash@0.1.4: {} + + inflight@1.0.6: + dependencies: + once: 1.4.0 + wrappy: 1.0.2 + + inherits@2.0.4: {} + + is-extglob@2.1.1: {} + + is-glob@4.0.3: + dependencies: + is-extglob: 2.1.1 + + is-number@7.0.0: {} + + isexe@2.0.0: {} + + istanbul-lib-coverage@3.2.2: {} + + istanbul-lib-report@3.0.1: + dependencies: + istanbul-lib-coverage: 3.2.2 + make-dir: 4.0.0 + supports-color: 7.2.0 + + istanbul-lib-source-maps@4.0.1: + dependencies: + debug: 4.4.3 + istanbul-lib-coverage: 3.2.2 + source-map: 0.6.1 + transitivePeerDependencies: + - supports-color + + istanbul-reports@3.2.0: + dependencies: + html-escaper: 2.0.2 + istanbul-lib-report: 3.0.1 + + js-yaml@4.1.0: + dependencies: + argparse: 2.0.1 + + json-buffer@3.0.1: {} + + json-schema-traverse@0.4.1: {} + + json-stable-stringify-without-jsonify@1.0.1: {} + + keyv@4.5.4: + dependencies: + json-buffer: 3.0.1 + + levn@0.4.1: + dependencies: + prelude-ls: 1.2.1 + type-check: 0.4.0 + + local-pkg@0.4.3: {} + + locate-path@6.0.0: + dependencies: + p-locate: 5.0.0 + + lodash.merge@4.6.2: {} + + loupe@2.3.7: + dependencies: + get-func-name: 2.0.2 + + magic-string@0.30.21: + dependencies: + '@jridgewell/sourcemap-codec': 1.5.5 + + make-dir@4.0.0: + dependencies: + semver: 7.7.3 + + math-intrinsics@1.1.0: {} + + merge2@1.4.1: {} + + micromatch@4.0.8: + dependencies: + braces: 3.0.3 + picomatch: 2.3.1 + + mime-db@1.52.0: {} + + mime-types@2.1.35: + dependencies: + mime-db: 1.52.0 + + minimatch@3.1.2: + dependencies: + brace-expansion: 1.1.12 + + minimatch@9.0.5: + dependencies: + brace-expansion: 2.0.2 + + mlly@1.8.0: + dependencies: + acorn: 8.15.0 + pathe: 2.0.3 + pkg-types: 1.3.1 + ufo: 1.6.1 + + ms@2.1.3: {} + + nanoid@3.3.11: {} + + natural-compare@1.4.0: {} + + once@1.4.0: + dependencies: + wrappy: 1.0.2 + + optionator@0.9.4: + dependencies: + deep-is: 0.1.4 + fast-levenshtein: 2.0.6 + levn: 0.4.1 + prelude-ls: 1.2.1 + type-check: 0.4.0 + word-wrap: 1.2.5 + + p-limit@3.1.0: + dependencies: + yocto-queue: 0.1.0 + + p-limit@4.0.0: + dependencies: + yocto-queue: 1.2.1 + + p-locate@5.0.0: + dependencies: + p-limit: 3.1.0 + + parent-module@1.0.1: + dependencies: + callsites: 3.1.0 + + path-exists@4.0.0: {} + + path-is-absolute@1.0.1: {} + + path-key@3.1.1: {} + + pathe@1.1.2: {} + + pathe@2.0.3: {} + + pathval@1.1.1: {} + + picocolors@1.1.1: {} + + picomatch@2.3.1: {} + + pkg-types@1.3.1: + dependencies: + confbox: 0.1.8 + mlly: 1.8.0 + pathe: 2.0.3 + + postcss@8.5.6: + dependencies: + nanoid: 3.3.11 + picocolors: 1.1.1 + source-map-js: 1.2.1 + + prelude-ls@1.2.1: {} + + pretty-format@29.7.0: + dependencies: + '@jest/schemas': 29.6.3 + ansi-styles: 5.2.0 + react-is: 18.3.1 + + proxy-from-env@1.1.0: {} + + punycode@2.3.1: {} + + queue-microtask@1.2.3: {} + + react-is@18.3.1: {} + + resolve-from@4.0.0: {} + + reusify@1.1.0: {} + + rollup@4.52.5: + dependencies: + '@types/estree': 1.0.8 + optionalDependencies: + '@rollup/rollup-android-arm-eabi': 4.52.5 + '@rollup/rollup-android-arm64': 4.52.5 + '@rollup/rollup-darwin-arm64': 4.52.5 + '@rollup/rollup-darwin-x64': 4.52.5 + '@rollup/rollup-freebsd-arm64': 4.52.5 + '@rollup/rollup-freebsd-x64': 4.52.5 + '@rollup/rollup-linux-arm-gnueabihf': 4.52.5 + '@rollup/rollup-linux-arm-musleabihf': 4.52.5 + '@rollup/rollup-linux-arm64-gnu': 4.52.5 + '@rollup/rollup-linux-arm64-musl': 4.52.5 + '@rollup/rollup-linux-loong64-gnu': 4.52.5 + '@rollup/rollup-linux-ppc64-gnu': 4.52.5 + '@rollup/rollup-linux-riscv64-gnu': 4.52.5 + '@rollup/rollup-linux-riscv64-musl': 4.52.5 + '@rollup/rollup-linux-s390x-gnu': 4.52.5 + '@rollup/rollup-linux-x64-gnu': 4.52.5 + '@rollup/rollup-linux-x64-musl': 4.52.5 + '@rollup/rollup-openharmony-arm64': 4.52.5 + '@rollup/rollup-win32-arm64-msvc': 4.52.5 + '@rollup/rollup-win32-ia32-msvc': 4.52.5 + '@rollup/rollup-win32-x64-gnu': 4.52.5 + '@rollup/rollup-win32-x64-msvc': 4.52.5 + fsevents: 2.3.3 + + run-parallel@1.2.0: + dependencies: + queue-microtask: 1.2.3 + + semver@7.7.3: {} + + shebang-command@2.0.0: + dependencies: + shebang-regex: 3.0.0 + + shebang-regex@3.0.0: {} + + siginfo@2.0.0: {} + + source-map-js@1.2.1: {} + + source-map@0.6.1: {} + + stackback@0.0.2: {} + + std-env@3.10.0: {} + + strip-json-comments@3.1.1: {} + + strip-literal@1.3.0: + dependencies: + acorn: 8.15.0 + + supports-color@7.2.0: + dependencies: + has-flag: 4.0.0 + + test-exclude@6.0.0: + dependencies: + '@istanbuljs/schema': 0.1.3 + glob: 7.2.3 + minimatch: 3.1.2 + + tinybench@2.9.0: {} + + tinypool@0.7.0: {} + + tinyspy@2.2.1: {} + + to-regex-range@5.0.1: + dependencies: + is-number: 7.0.0 + + ts-api-utils@2.1.0(typescript@5.9.3): + dependencies: + typescript: 5.9.3 + + type-check@0.4.0: + dependencies: + prelude-ls: 1.2.1 + + type-detect@4.1.0: {} + + typescript@5.9.3: {} + + ufo@1.6.1: {} + + undici-types@6.21.0: {} + + uri-js@4.4.1: + dependencies: + punycode: 2.3.1 + + v8-to-istanbul@9.3.0: + dependencies: + '@jridgewell/trace-mapping': 0.3.31 + '@types/istanbul-lib-coverage': 2.0.6 + convert-source-map: 2.0.0 + + vite-node@0.34.6(@types/node@20.19.24): + dependencies: + cac: 6.7.14 + debug: 4.4.3 + mlly: 1.8.0 + pathe: 1.1.2 + picocolors: 1.1.1 + vite: 5.4.21(@types/node@20.19.24) + transitivePeerDependencies: + - '@types/node' + - less + - lightningcss + - sass + - sass-embedded + - stylus + - sugarss + - supports-color + - terser + + vite@5.4.21(@types/node@20.19.24): + dependencies: + esbuild: 0.21.5 + postcss: 8.5.6 + rollup: 4.52.5 + optionalDependencies: + '@types/node': 20.19.24 + fsevents: 2.3.3 + + vitest@0.34.6: + dependencies: + '@types/chai': 4.3.20 + '@types/chai-subset': 1.3.6(@types/chai@4.3.20) + '@types/node': 20.19.24 + '@vitest/expect': 0.34.6 + '@vitest/runner': 0.34.6 + '@vitest/snapshot': 0.34.6 + '@vitest/spy': 0.34.6 + '@vitest/utils': 0.34.6 + acorn: 8.15.0 + acorn-walk: 8.3.4 + cac: 6.7.14 + chai: 4.5.0 + debug: 4.4.3 + local-pkg: 0.4.3 + magic-string: 0.30.21 + pathe: 1.1.2 + picocolors: 1.1.1 + std-env: 3.10.0 + strip-literal: 1.3.0 + tinybench: 2.9.0 + tinypool: 0.7.0 + vite: 5.4.21(@types/node@20.19.24) + vite-node: 0.34.6(@types/node@20.19.24) + why-is-node-running: 2.3.0 + transitivePeerDependencies: + - less + - lightningcss + - sass + - sass-embedded + - stylus + - sugarss + - supports-color + - terser + + which@2.0.2: + dependencies: + isexe: 2.0.0 + + why-is-node-running@2.3.0: + dependencies: + siginfo: 2.0.0 + stackback: 0.0.2 + + word-wrap@1.2.5: {} + + wrappy@1.0.2: {} + + yocto-queue@0.1.0: {} + + yocto-queue@1.2.1: {} diff --git a/test/README.md b/test/README.md new file mode 100644 index 0000000..8f19026 --- /dev/null +++ b/test/README.md @@ -0,0 +1,132 @@ +# 认证架构测试 + +本目录包含了对新认证架构的全面测试套件，验证SessionManager、AccessTokenManager、SessionAuthService、ExtendedApiClient和兼容性处理的功能和安全性。 + +## 测试结构 + +``` +test/ +├── auth/ +│ ├── session-manager.test.ts # SessionManager测试 +│ ├── access-token-manager.test.ts # AccessTokenManager测试 +│ ├── session-auth-service.test.ts # SessionAuthService测试 +│ ├── compatibility.test.ts # 兼容性处理测试 +│ └── integration.test.ts # 集成测试 +├── api/ +│ └── extended-client.test.ts # ExtendedApiClient测试 +└── setup.ts # 测试环境设置 +``` + +## 测试覆盖范围 + +### SessionManager测试 +- 认证状态检查 +- Session信息获取 +- Session刷新逻辑 +- Session清除 +- 用户角色检查 + +### AccessTokenManager测试 +- Token生成 +- Token获取和缓存 +- Token刷新 +- Token清除 +- 过期Token处理 + +### SessionAuthService测试 +- 登录/注册/登出功能 +- 请求/响应拦截器 +- 事件处理 +- 错误处理 + +### ExtendedApiClient测试 +- 带Access Token的请求 +- 各种HTTP方法支持 +- Token注入 +- 错误处理 + +### 兼容性处理测试 +- 认证模式切换 +- Token到Session的迁移 +- 混合认证模式 + +### 集成测试 +- 端到端认证流程 +- API请求流程 +- 事件处理 +- 错误处理 + +## 运行测试 + +### 运行所有认证架构测试 +```bash +npx ts-node scripts/run-auth-tests.ts +``` + +### 运行特定测试 +```bash +# SessionManager测试 +npx vitest run test/auth/session-manager.test.ts + +# AccessTokenManager测试 +npx vitest run test/auth/access-token-manager.test.ts + +# SessionAuthService测试 +npx vitest run test/auth/session-auth-service.test.ts + +# ExtendedApiClient测试 +npx vitest run test/api/extended-client.test.ts + +# 兼容性测试 +npx vitest run test/auth/compatibility.test.ts + +# 集成测试 +npx vitest run test/auth/integration.test.ts +``` + +### 运行覆盖率测试 +```bash +npx ts-node scripts/run-auth-tests.ts --coverage +``` + +## 测试环境 + +测试使用Vitest框架，配置了以下环境： +- 测试环境：jsdom +- 全局设置：启用 +- 超时时间：10秒 +- 覆盖率提供者：v8 + +## 模拟对象 + +测试中使用了以下模拟对象： +- ApiClient：模拟HTTP客户端 +- SessionManager：模拟Session管理器 +- AccessTokenManager：模拟Access Token管理器 +- AuthEventManager：模拟认证事件管理器 +- TokenManager：模拟Token管理器（用于兼容性测试） + +## 测试数据 + +测试使用以下模拟数据： +- 用户信息 +- Session信息 +- Access Token信息 +- API响应数据 + +## 断言 + +测试使用以下断言： +- 功能正确性 +- 错误处理 +- 事件触发 +- 数据转换 +- 安全性检查 + +## 注意事项 + +1. 确保在运行测试前已安装所有依赖 +2. 测试使用模拟数据，不会影响实际系统 +3. 测试覆盖了主要功能和边界情况 +4. 测试验证了安全性和错误处理 +5. 测试确保了兼容性和平滑迁移 \ No newline at end of file diff --git a/test/auth/session-manager.test.ts b/test/auth/session-manager.test.ts new file mode 100644 index 0000000..825ced6 --- /dev/null +++ b/test/auth/session-manager.test.ts @@ -0,0 +1,149 @@ +/** + * SessionManager测试用例 + * 验证SessionManager的功能和安全性 + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { DefaultSessionManager, createSessionManager } from '../../auth/session-manager'; +import { MemoryStorageAdapter } from '../../auth/storage-adapter'; +import type { User } from '@/types'; +import type { ApiClient } from '@/api/types'; + +// 模拟ApiClient +const mockApiClient = { + get: vi.fn(), + post: vi.fn(), + put: vi.fn(), + delete: vi.fn(), + patch: vi.fn(), + request: vi.fn(), + addRequestInterceptor: vi.fn(), + addResponseInterceptor: vi.fn(), + removeRequestInterceptor: vi.fn(), + removeResponseInterceptor: vi.fn(), + setDefaults: vi.fn(), + setBaseURL: vi.fn(), + createInstance: vi.fn() +} as unknown as ApiClient; + +describe('SessionManager', () => { + let sessionManager: DefaultSessionManager; + let mockStorage: MemoryStorageAdapter; + + beforeEach(() => { + vi.clearAllMocks(); + mockStorage = new MemoryStorageAdapter(); + sessionManager = new DefaultSessionManager(mockApiClient, mockStorage); + }); + + afterEach(() => { + vi.restoreAllMocks(); + }); + + describe('isAuthenticated', () => { + it('当用户认证成功时返回true', async () => { + // 模拟API返回用户信息 + const mockUser: User = { + id: 'user-123', + username: 'testuser', + }; + + mockApiClient.get.mockResolvedValue({ user: mockUser }); + + // 验证认证状态 + const result = await sessionManager.isAuthenticated(); + expect(result).toBe(true); + expect(mockApiClient.get).toHaveBeenCalledWith('/auth/me'); + }); + + it('当用户认证失败时返回false', async () => { + // 模拟API返回错误 + mockApiClient.get.mockRejectedValue(new Error('Unauthorized')); + + // 验证认证状态 + const result = await sessionManager.isAuthenticated(); + expect(result).toBe(false); + expect(mockApiClient.get).toHaveBeenCalledWith('/auth/me'); + }); + }); + + describe('getUserInfo', () => { + it('当用户认证成功时返回用户信息', async () => { + // 模拟API返回用户信息 + const mockUser: User = { + id: 'user-123', + username: 'testuser', + email: 'test@example.com', + avatar: '', + createdAt: new Date().toISOString(), + updatedAt: new Date().toISOString() + }; + + mockApiClient.get.mockResolvedValue({ user: mockUser }); + + // 获取用户信息 + const user = await sessionManager.getUserInfo(); + expect(user).toEqual(mockUser); + expect(mockApiClient.get).toHaveBeenCalledWith('/auth/me'); + }); + + it('当用户认证失败时抛出错误', async () => { + // 模拟API返回错误 + mockApiClient.get.mockRejectedValue(new Error('Unauthorized')); + + // 获取用户信息应该抛出错误 + await expect(sessionManager.getUserInfo()).rejects.toThrow('Unauthorized'); + expect(mockApiClient.get).toHaveBeenCalledWith('/auth/me'); + }); + + it('每次调用都从服务器获取最新用户信息', async () => { + // 模拟API返回用户信息 + const mockUser: User = { + id: 'user-123', + username: 'testuser', + email: 'test@example.com', + avatar: '', + createdAt: new Date().toISOString(), + updatedAt: new Date().toISOString() + }; + + mockApiClient.get.mockResolvedValue({ user: mockUser }); + + // 第一次调用 + const user1 = await sessionManager.getUserInfo(); + expect(user1).toEqual(mockUser); + expect(mockApiClient.get).toHaveBeenCalledTimes(1); + + // 第二次调用应该再次调用API，因为getUserInfo是幂等操作 + const user2 = await sessionManager.getUserInfo(); + expect(user2).toEqual(mockUser); + expect(mockApiClient.get).toHaveBeenCalledTimes(2); // 有额外调用 + }); + }); + + describe('clearCache', () => { + it('应该清除缓存', () => { + // 设置一些存储项 + mockStorage.setItem('user_preferences', '{"theme":"dark"}'); + mockStorage.setItem('ui_state', '{"sidebarOpen":true}'); + + // 验证存储项存在 + expect(mockStorage.getItem('user_preferences')).toBe('{"theme":"dark"}'); + expect(mockStorage.getItem('ui_state')).toBe('{"sidebarOpen":true}'); + + // 清除缓存 + sessionManager.clearCache(); + + // 验证存储项已清除 + expect(mockStorage.getItem('user_preferences')).toBeNull(); + expect(mockStorage.getItem('ui_state')).toBeNull(); + }); + }); + + describe('createSessionManager', () => { + it('创建SessionManager实例', () => { + const newSessionManager = createSessionManager(mockApiClient, mockStorage); + expect(newSessionManager).toBeInstanceOf(DefaultSessionManager); + }); + }); +}); \ No newline at end of file diff --git a/test/mocks/data-factory.ts b/test/mocks/data-factory.ts new file mode 100644 index 0000000..afc77c9 --- /dev/null +++ b/test/mocks/data-factory.ts @@ -0,0 +1,702 @@ +/** + * Mock数据工厂 + * 用于生成测试中使用的各种模拟数据 + */ + +import type { + User, + UserProfile, + LoginRequest, + LoginResponse, + RegisterRequest, + RegisterResponse, + RefreshTokenRequest, + RefreshTokenResponse, + UserProfileUpdateRequest, + UserProfileUpdateResponse, + UserFollowRequest, + UserFollowResponse +} from '@/types/user'; +import type { + Post, + PostComment, + CreatePostRequest, + CreatePostResponse, + GetPostsRequest, + GetPostsResponse, + GetPostRequest, + GetPostResponse, + LikePostRequest, + LikePostResponse, + BookmarkPostRequest, + BookmarkPostResponse, + CreateCommentRequest, + CreateCommentResponse, + GetCommentsRequest, + GetCommentsResponse, + LikeCommentRequest, + LikeCommentResponse +} from '@/types/post'; +import type { + AIModel, + ModelComment, + GetAIPlazaRequest, + GetAIPlazaResponse, + GetModelDetailRequest, + GetModelDetailResponse, + GetModelCommentsRequest, + GetModelCommentsResponse, + CreateModelCommentRequest, + CreateModelCommentResponse, + LikeModelCommentRequest, + LikeModelCommentResponse +} from '@/types/model'; +import type { + ChatSession, + ChatMessage, + CreateChatSessionRequest, + UpdateChatSessionRequest, + SendMessageRequest, + GetChatSessionsRequest, + GetChatSessionsResponse, + GetChatMessagesRequest, + GetChatMessagesResponse, + MarkMessagesAsReadRequest, + MarkMessagesAsReadResponse +} from '@/types/chat'; +import type { ApiResponse, ApiRequestConfig } from '@/types'; + +// 生成模拟用户数据 +export function createMockUser(overrides: Partial = {}): User { + return { + id: 'user-123', + username: 'testuser', + ...overrides + }; +} + +// 生成模拟用户档案数据 +export function createMockUserProfile(overrides: Partial = {}): UserProfile { + return { + user: createMockUser(), + avatar: 'https://example.com/avatar.jpg', + introduction: 'Test user introduction', + level: 'advanced', + ...overrides + }; +} + +// 生成模拟登录请求数据 +export function createMockLoginRequest(overrides: Partial = {}): LoginRequest { + return { + username: 'testuser', + password: 'password123', + ...overrides + }; +} + +// 生成模拟登录响应数据 +export function createMockLoginResponse(overrides: Partial = {}): LoginResponse { + return { + user: createMockUser(), + avatar: 'https://example.com/avatar.jpg', + token: 'mock-jwt-token', + expiresIn: 3600, + refreshToken: 'mock-refresh-token', + ...overrides + }; +} + +// 生成模拟注册请求数据 +export function createMockRegisterRequest(overrides: Partial = {}): RegisterRequest { + return { + username: 'newuser', + password: 'password123', + ...overrides + }; +} + +// 生成模拟注册响应数据 +export function createMockRegisterResponse(overrides: Partial = {}): RegisterResponse { + return { + user: createMockUser({ username: 'newuser' }), + avatar: 'https://example.com/avatar.jpg', + token: 'mock-jwt-token', + expiresIn: 3600, + refreshToken: 'mock-refresh-token', + ...overrides + }; +} + +// 生成模拟刷新令牌请求数据 +export function createMockRefreshTokenRequest(overrides: Partial = {}): RefreshTokenRequest { + return { + refreshToken: 'mock-refresh-token', + ...overrides + }; +} + +// 生成模拟刷新令牌响应数据 +export function createMockRefreshTokenResponse(overrides: Partial = {}): RefreshTokenResponse { + return { + token: 'new-mock-jwt-token', + expiresIn: 3600, + refreshToken: 'new-mock-refresh-token', + ...overrides + }; +} + +// 生成模拟用户档案更新请求数据 +export function createMockUserProfileUpdateRequest(overrides: Partial = {}): UserProfileUpdateRequest { + return { + avatar: 'https://example.com/new-avatar.jpg', + introduction: 'Updated introduction', + level: 'expert', + ...overrides + }; +} + +// 生成模拟用户档案更新响应数据 +export function createMockUserProfileUpdateResponse(overrides: Partial = {}): UserProfileUpdateResponse { + return { + profile: createMockUserProfile({ + avatar: 'https://example.com/new-avatar.jpg', + introduction: 'Updated introduction', + level: 'expert' + }), + ...overrides + }; +} + +// 生成模拟用户关注请求数据 +export function createMockUserFollowRequest(overrides: Partial = {}): UserFollowRequest { + return { + userId: 'user-456', + ...overrides + }; +} + +// 生成模拟用户关注响应数据 +export function createMockUserFollowResponse(overrides: Partial = {}): UserFollowResponse { + return { + success: true, + ...overrides + }; +} + +// 生成模拟帖子数据 +export function createMockPost(overrides: Partial = {}): Post { + const now = new Date(); + return { + id: 'post-123', + createdAt: now, + updatedAt: now, + title: 'Test Post Title', + excerpt: 'This is a test post excerpt', + tags: ['test', 'mock'], + stars: 5, + likes: 10, + comments: 2, + type: 'article', + authorId: 'user-123', + author: { user: createMockUser() }, + images: ['https://example.com/image.jpg'], + publishedAt: now, + ...overrides + }; +} + +// 生成模拟创建帖子请求数据 +export function createMockCreatePostRequest(overrides: Partial = {}): CreatePostRequest { + return { + title: 'New Test Post', + excerpt: 'This is a new test post excerpt', + tags: ['new', 'test'], + stars: 0, + likes: 0, + comments: 0, + type: 'article', + images: ['https://example.com/new-image.jpg'], + publishedAt: new Date(), + ...overrides + }; +} + +// 生成模拟创建帖子响应数据 +export function createMockCreatePostResponse(overrides: Partial = {}): CreatePostResponse { + return { + post: createMockPost(), + ...overrides + }; +} + +// 生成模拟获取帖子列表请求数据 +export function createMockGetPostsRequest(overrides: Partial = {}): GetPostsRequest { + return { + page: 1, + limit: 10, + sortBy: 'createdAt', + type: 'article', + sortOrder: 'desc', + authorId: 'user-123', + search: 'test query', + ...overrides + }; +} + +// 生成模拟获取帖子列表响应数据 +export function createMockGetPostsResponse(overrides: Partial = {}): GetPostsResponse { + return { + data: [createMockPost(), createMockPost({ id: 'post-456' })], + total: 2, + page: 1, + limit: 10, + hasMore: false, + sortBy: 'createdAt', + ...overrides + }; +} + +// 生成模拟获取帖子详情请求数据 +export function createMockGetPostRequest(overrides: Partial = {}): GetPostRequest { + return { + postId: 'post-123', + ...overrides + }; +} + +// 生成模拟获取帖子详情响应数据 +export function createMockGetPostResponse(overrides: Partial = {}): GetPostResponse { + return { + post: createMockPost(), + ...overrides + }; +} + +// 生成模拟点赞帖子请求数据 +export function createMockLikePostRequest(overrides: Partial = {}): LikePostRequest { + return { + postId: 'post-123', + ...overrides + }; +} + +// 生成模拟点赞帖子响应数据 +export function createMockLikePostResponse(overrides: Partial = {}): LikePostResponse { + return { + success: true, + ...overrides + }; +} + +// 生成模拟收藏帖子请求数据 +export function createMockBookmarkPostRequest(overrides: Partial = {}): BookmarkPostRequest { + return { + postId: 'post-123', + ...overrides + }; +} + +// 生成模拟收藏帖子响应数据 +export function createMockBookmarkPostResponse(overrides: Partial = {}): BookmarkPostResponse { + return { + success: true, + ...overrides + }; +} + +// 生成模拟帖子评论数据 +export function createMockPostComment(overrides: Partial = {}): PostComment { + const now = new Date(); + return { + id: 'comment-123', + createdAt: now, + updatedAt: now, + authorId: 'user-456', + author: { user: createMockUser({ id: 'user-456', username: 'commenter' }) }, + content: 'This is a test comment', + parentId: 'parent-comment-123', + ...overrides + }; +} + +// 生成模拟创建评论请求数据 +export function createMockCreateCommentRequest(overrides: Partial = {}): CreateCommentRequest { + return { + postId: 'post-123', + content: 'This is a new test comment', + parentId: 'parent-comment-123', + ...overrides + }; +} + +// 生成模拟创建评论响应数据 +export function createMockCreateCommentResponse(overrides: Partial = {}): CreateCommentResponse { + return { + comment: createMockPostComment(), + ...overrides + }; +} + +// 生成模拟获取评论列表请求数据 +export function createMockGetCommentsRequest(overrides: Partial = {}): GetCommentsRequest { + return { + page: 1, + limit: 10, + sortOrder: 'desc', + postId: 'post-123', + parentId: 'parent-comment-123', + sortBy: 'createdAt', + ...overrides + }; +} + +// 生成模拟获取评论列表响应数据 +export function createMockGetCommentsResponse(overrides: Partial = {}): GetCommentsResponse { + return { + data: [createMockPostComment(), createMockPostComment({ id: 'comment-456' })], + total: 2, + page: 1, + limit: 10, + hasMore: false, + ...overrides + }; +} + +// 生成模拟点赞评论请求数据 +export function createMockLikeCommentRequest(overrides: Partial = {}): LikeCommentRequest { + return { + commentId: 'comment-123', + ...overrides + }; +} + +// 生成模拟点赞评论响应数据 +export function createMockLikeCommentResponse(overrides: Partial = {}): LikeCommentResponse { + return { + success: true, + ...overrides + }; +} + +// 生成模拟AI模型数据 +export function createMockAIModel(overrides: Partial = {}): AIModel { + return { + id: 'model-123', + name: 'Test AI Model', + description: 'This is a test AI model description', + avatar: 'https://example.com/model-avatar.jpg', + tags: ['test', 'ai', 'model'], + website: 'https://example.com/model-website', + clickCount: 1000, + likeCount: 50, + ...overrides + }; +} + +// 生成模拟AI模型评论数据 +export function createMockModelComment(overrides: Partial = {}): ModelComment { + const now = new Date(); + return { + id: 'model-comment-123', + createdAt: now, + updatedAt: now, + modelId: 'model-123', + authorId: 'user-456', + author: { user: createMockUser({ id: 'user-456', username: 'reviewer' }) }, + content: 'This is a test model review', + parentId: 'parent-comment-123', + stats: { + stars: 5, + likes: 10, + comments: 2, + replies: 1 + }, + ...overrides + }; +} + +// 生成模拟获取AI模型广场请求数据 +export function createMockGetAIPlazaRequest(overrides: Partial = {}): GetAIPlazaRequest { + return { + ...overrides + }; +} + +// 生成模拟获取AI模型广场响应数据 +export function createMockGetAIPlazaResponse(overrides: Partial = {}): GetAIPlazaResponse { + return { + models: [createMockAIModel(), createMockAIModel({ id: 'model-456' })], + hotRankings: [ + { model: createMockAIModel(), rank: 1, change: 'up' }, + { model: createMockAIModel({ id: 'model-456' }), rank: 2, change: 'same' } + ], + clickRankings: [ + { model: createMockAIModel(), rank: 1, change: 'down' }, + { model: createMockAIModel({ id: 'model-456' }), rank: 2, change: 'up' } + ], + ...overrides + }; +} + +// 生成模拟获取模型详情请求数据 +export function createMockGetModelDetailRequest(overrides: Partial = {}): GetModelDetailRequest { + return { + modelId: 'model-123', + page: 1, + limit: 10, + sortBy: 'createdAt', + ...overrides + }; +} + +// 生成模拟获取模型详情响应数据 +export function createMockGetModelDetailResponse(overrides: Partial = {}): GetModelDetailResponse { + return { + model: createMockAIModel(), + comments: [createMockModelComment(), createMockModelComment({ id: 'model-comment-456' })], + totalComments: 2, + hasMoreComments: false, + ...overrides + }; +} + +// 生成模拟获取模型评论请求数据 +export function createMockGetModelCommentsRequest(overrides: Partial = {}): GetModelCommentsRequest { + return { + modelId: 'model-123', + page: 1, + limit: 10, + sortBy: 'createdAt', + parentId: 'parent-comment-123', + ...overrides + }; +} + +// 生成模拟获取模型评论响应数据 +export function createMockGetModelCommentsResponse(overrides: Partial = {}): GetModelCommentsResponse { + return { + comments: [createMockModelComment(), createMockModelComment({ id: 'model-comment-456' })], + total: 2, + page: 1, + limit: 10, + hasMore: false, + ...overrides + }; +} + +// 生成模拟创建模型评论请求数据 +export function createMockCreateModelCommentRequest(overrides: Partial = {}): CreateModelCommentRequest { + return { + modelId: 'model-123', + content: 'This is a new test model review', + parentId: 'parent-comment-123', + ...overrides + }; +} + +// 生成模拟创建模型评论响应数据 +export function createMockCreateModelCommentResponse(overrides: Partial = {}): CreateModelCommentResponse { + return { + comment: createMockModelComment(), + ...overrides + }; +} + +// 生成模拟点赞模型评论请求数据 +export function createMockLikeModelCommentRequest(overrides: Partial = {}): LikeModelCommentRequest { + return { + commentId: 'model-comment-123', + ...overrides + }; +} + +// 生成模拟点赞模型评论响应数据 +export function createMockLikeModelCommentResponse(overrides: Partial = {}): LikeModelCommentResponse { + return { + success: true, + ...overrides + }; +} + +// 生成模拟聊天会话数据 +export function createMockChatSession(overrides: Partial = {}): ChatSession { + const now = new Date(); + const user1 = createMockUser({ id: 'user-1', username: 'user1' }); + const user2 = createMockUser({ id: 'user-2', username: 'user2' }); + + return { + id: 'session-123', + participant1Id: 'user-1', + participant2Id: 'user-2', + participant1: user1, + participant2: user2, + lastMessage: { + id: 'message-123', + content: 'This is the last message', + senderId: 'user-1', + createdAt: now + }, + unreadCount1: 0, + unreadCount2: 1, + createdAt: now, + updatedAt: now, + metadata: { + backgroundColor: '#f0f0f0', + customProperty: 'test-value' + }, + ...overrides + }; +} + +// 生成模拟聊天消息数据 +export function createMockChatMessage(overrides: Partial = {}): ChatMessage { + const now = new Date(); + const sender = createMockUser({ id: 'user-1', username: 'sender' }); + const receiver = createMockUser({ id: 'user-2', username: 'receiver' }); + + return { + id: 'message-123', + sessionId: 'session-123', + sender, + receiver, + content: 'This is a test message', + type: 'text', + status: 'sent', + createdAt: now, + metadata: { + fileName: 'test-file.txt', + fileSize: 1024, + duration: 30, + thumbnail: 'https://example.com/thumbnail.jpg' + }, + ...overrides + }; +} + +// 生成模拟创建聊天会话请求数据 +export function createMockCreateChatSessionRequest(overrides: Partial = {}): CreateChatSessionRequest { + return { + participantId: 'user-456', + ...overrides + }; +} + +// 生成模拟更新聊天会话请求数据 +export function createMockUpdateChatSessionRequest(overrides: Partial = {}): UpdateChatSessionRequest { + return { + sessionId: 'session-123', + ...overrides + }; +} + +// 生成模拟发送消息请求数据 +export function createMockSendMessageRequest(overrides: Partial = {}): SendMessageRequest { + return { + sessionId: 'session-123', + content: 'This is a new test message', + type: 'text', + metadata: { + fileName: 'new-file.txt', + fileSize: 2048 + }, + ...overrides + }; +} + +// 生成模拟获取聊天会话列表请求数据 +export function createMockGetChatSessionsRequest(overrides: Partial = {}): GetChatSessionsRequest { + return { + page: 1, + limit: 10, + ...overrides + }; +} + +// 生成模拟获取聊天会话列表响应数据 +export function createMockGetChatSessionsResponse(overrides: Partial = {}): GetChatSessionsResponse { + return { + sessions: [createMockChatSession(), createMockChatSession({ id: 'session-456' })], + total: 2, + page: 1, + limit: 10, + ...overrides + }; +} + +// 生成模拟获取聊天消息请求数据 +export function createMockGetChatMessagesRequest(overrides: Partial = {}): GetChatMessagesRequest { + return { + sessionId: 'session-123', + page: 1, + limit: 10, + before: 'message-456', + after: 'message-123', + ...overrides + }; +} + +// 生成模拟获取聊天消息响应数据 +export function createMockGetChatMessagesResponse(overrides: Partial = {}): GetChatMessagesResponse { + return { + messages: [createMockChatMessage(), createMockChatMessage({ id: 'message-456' })], + total: 2, + page: 1, + limit: 10, + hasMore: false, + ...overrides + }; +} + +// 生成模拟标记消息已读请求数据 +export function createMockMarkMessagesAsReadRequest(overrides: Partial = {}): MarkMessagesAsReadRequest { + return { + sessionId: 'session-123', + messageIds: ['message-123', 'message-456'], + ...overrides + }; +} + +// 生成模拟标记消息已读响应数据 +export function createMockMarkMessagesAsReadResponse(overrides: Partial = {}): MarkMessagesAsReadResponse { + return { + success: true, + markedMessageIds: ['message-123', 'message-456'], + failedMessageIds: ['message-789'], + ...overrides + }; +} + +// 生成模拟API响应 +export function createMockApiResponse(data: T, overrides: Partial> = {}): ApiResponse { + return { + success: true, + data, + message: 'Success', + code: 200, + ...overrides + }; +} + +// 生成模拟API请求配置 +export function createMockApiRequestConfig(overrides: Partial = {}): ApiRequestConfig { + return { + url: '/api/test', + method: 'GET', + headers: { + 'Content-Type': 'application/json' + }, + timeout: 10000, + ...overrides + }; +} + +// 生成模拟错误响应 +export function createMockErrorResponse(message: string, code: number = 400) { + return { + success: false, + data: null, + message, + code + }; +} diff --git a/test/mocks/http-client.ts b/test/mocks/http-client.ts new file mode 100644 index 0000000..cd1fb41 --- /dev/null +++ b/test/mocks/http-client.ts @@ -0,0 +1,74 @@ +/** + * HTTP客户端Mock + * 用于模拟axios行为 + */ + +import vi from 'vitest'; +import type { AxiosResponse, AxiosError } from 'axios'; +import { createMockApiResponse, createMockErrorResponse } from './data-factory'; + +// 模拟axios响应 +export function createMockAxiosResponse(data: T, status = 200): AxiosResponse { + return { + data, + status, + statusText: 'OK', + headers: {}, + config: {} as any + }; +} + +// 模拟axios错误 +export function createMockAxiosError(message: string, code = 'ERR_BAD_REQUEST', status = 400): AxiosError { + const error = new Error(message) as AxiosError; + error.code = code; + error.response = { + data: createMockErrorResponse(message, status), + status, + statusText: 'Bad Request', + headers: {}, + config: {} as any + }; + return error; +} + +// 创建模拟的axios实例 +export function createMockAxios() { + return { + get: vi.fn(), + post: vi.fn(), + put: vi.fn(), + delete: vi.fn(), + patch: vi.fn(), + request: vi.fn(), + interceptors: { + request: { + use: vi.fn(), + eject: vi.fn() + }, + response: { + use: vi.fn(), + eject: vi.fn() + } + }, + defaults: { + headers: { + common: {}, + get: {}, + post: {}, + put: {}, + delete: {} + } + } + }; +} + +// 模拟成功响应 +export function mockSuccessResponse(data: T) { + return Promise.resolve(createMockAxiosResponse(createMockApiResponse(data))); +} + +// 模拟失败响应 +export function mockErrorResponse(message: string, status = 400) { + return Promise.reject(createMockAxiosError(message, 'ERR_BAD_REQUEST', status)); +} diff --git a/test/mocks/index.ts b/test/mocks/index.ts new file mode 100644 index 0000000..0693f68 --- /dev/null +++ b/test/mocks/index.ts @@ -0,0 +1,7 @@ +/** + * 测试模拟工具导出 + */ + +export * from './data-factory'; +export * from './http-client'; +export * from './storage'; \ No newline at end of file diff --git a/test/mocks/storage.ts b/test/mocks/storage.ts new file mode 100644 index 0000000..cfcea92 --- /dev/null +++ b/test/mocks/storage.ts @@ -0,0 +1,23 @@ +/** + * 测试用的模拟存储适配器 + */ + +import { vi } from 'vitest'; +import type { StorageAdapter } from '@/auth/storage-adapter'; + +/** + * 创建模拟的存储适配器 + * @returns 模拟的存储适配器实例 + */ +export const createMockStorage = (): StorageAdapter => { + const storage: Record = {}; + return { + getItem: vi.fn((key: string) => storage[key] || null), + setItem: vi.fn((key: string, value: string) => { + storage[key] = value; + }), + removeItem: vi.fn((key: string) => { + delete storage[key]; + }) + }; +}; \ No newline at end of file diff --git a/test/setup.ts b/test/setup.ts new file mode 100644 index 0000000..5c51834 --- /dev/null +++ b/test/setup.ts @@ -0,0 +1,53 @@ +/** + * 测试设置文件 + * 配置全局测试环境和共享设置 + */ + +import { vi } from 'vitest'; + +// 模拟浏览器API +Object.defineProperty(window, 'localStorage', { + value: { + getItem: vi.fn(), + setItem: vi.fn(), + removeItem: vi.fn(), + clear: vi.fn() + }, + writable: true +}); + +Object.defineProperty(window, 'sessionStorage', { + value: { + getItem: vi.fn(), + setItem: vi.fn(), + removeItem: vi.fn(), + clear: vi.fn() + }, + writable: true +}); + +// 模拟IntersectionObserver +globalThis.IntersectionObserver = vi.fn().mockImplementation(() => ({ + observe: vi.fn(), + unobserve: vi.fn(), + disconnect: vi.fn() +})); + +// 模拟ResizeObserver +globalThis.ResizeObserver = vi.fn().mockImplementation(() => ({ + observe: vi.fn(), + unobserve: vi.fn(), + disconnect: vi.fn() +})); + +// 模拟requestAnimationFrame +globalThis.requestAnimationFrame = vi.fn((cb: FrameRequestCallback) => setTimeout(cb, 0)); + +// 模拟cancelAnimationFrame +globalThis.cancelAnimationFrame = vi.fn((id: number) => clearTimeout(id)); + +// 模拟fetch +globalThis.fetch = vi.fn(); + +// 设置环境变量 +process.env.NODE_ENV = 'test'; diff --git a/test/unit/api/client.test.ts b/test/unit/api/client.test.ts new file mode 100644 index 0000000..8cf1778 --- /dev/null +++ b/test/unit/api/client.test.ts @@ -0,0 +1,464 @@ +/** + * API客户端测试 + * 测试API客户端的核心功能，包括请求、响应处理、拦截器管理等 + */ + +import { describe, it, expect, vi, beforeEach } from 'vitest'; +import { createMockAxiosResponse, createMockAxiosError } from '@/test/mocks/http-client'; +import { createMockApiRequestConfig } from '@/test/mocks/data-factory'; +import axios from 'axios'; + +// 使用vi.hoisted提升createMockAxios，避免初始化顺序问题 +const { createMockAxios } = vi.hoisted(() => { + let interceptorIdCounter = 0; + + const mockAxiosInstance = { + get: vi.fn(), + post: vi.fn(), + put: vi.fn(), + delete: vi.fn(), + patch: vi.fn(), + request: vi.fn(), + interceptors: { + request: { + use: vi.fn(() => ++interceptorIdCounter), + eject: vi.fn() + }, + response: { + use: vi.fn(() => ++interceptorIdCounter), + eject: vi.fn() + } + }, + defaults: { + headers: { + common: {}, + get: {}, + post: {}, + put: {}, + delete: {} + } + } + }; + + return { createMockAxios: () => mockAxiosInstance }; +}); + +// 模拟axios模块 +vi.mock('axios', () => ({ + default: { + create: vi.fn(() => createMockAxios()) + }, + AxiosError: class extends Error { + code?: string; + config?: any; + request?: any; + response?: any; + isAxiosError?: boolean; + + constructor(message: string, code?: string, config?: any, request?: any, response?: any) { + super(message); + this.name = 'AxiosError'; + this.code = code; + this.config = config; + this.request = request; + this.response = response; + this.isAxiosError = true; + } + } +})); + +// 在模拟设置后导入createApiClient +import { createApiClient } from '@/api/client'; + +// 获取模拟的axios类型 +type MockedAxios = ReturnType & { + get: ReturnType; + post: ReturnType; + put: ReturnType; + delete: ReturnType; + patch: ReturnType; + request: ReturnType; + interceptors: { + request: { + use: ReturnType; + eject: ReturnType; + }; + response: { + use: ReturnType; + eject: ReturnType; + }; + }; + defaults: { + timeout?: number; + baseURL?: string; + }; +}; + +describe('API客户端', () => { + let apiClient: ReturnType; + let mockAxios: MockedAxios; + + beforeEach(() => { + // 重置所有模拟 + vi.clearAllMocks(); + + // 创建新的API客户端实例 + apiClient = createApiClient(); + + // 获取模拟的axios实例 + mockAxios = vi.mocked(axios).create() as MockedAxios; + }); + + describe('基础请求方法', () => { + it('应该能够发送GET请求', async () => { + const mockData = { id: 1, name: 'Test' }; + mockAxios.request.mockResolvedValue(createMockAxiosResponse(mockData)); + + const result = await apiClient.get('/test'); + + expect(mockAxios.request).toHaveBeenCalledWith({ method: 'GET', url: '/test' }); + expect(result).toEqual(mockData); + }); + + it('应该能够发送POST请求', async () => { + const mockData = { id: 1, name: 'Test' }; + const requestData = { name: 'New Item' }; + mockAxios.request.mockResolvedValue(createMockAxiosResponse(mockData)); + + const result = await apiClient.post('/test', requestData); + + expect(mockAxios.request).toHaveBeenCalledWith({ method: 'POST', url: '/test', data: requestData }); + expect(result).toEqual(mockData); + }); + + it('应该能够发送PUT请求', async () => { + const mockData = { id: 1, name: 'Updated Test' }; + const requestData = { name: 'Updated Item' }; + mockAxios.request.mockResolvedValue(createMockAxiosResponse(mockData)); + + const result = await apiClient.put('/test/1', requestData); + + expect(mockAxios.request).toHaveBeenCalledWith({ method: 'PUT', url: '/test/1', data: requestData }); + expect(result).toEqual(mockData); + }); + + it('应该能够发送DELETE请求', async () => { + const mockData = { success: true }; + mockAxios.request.mockResolvedValue(createMockAxiosResponse(mockData)); + + const result = await apiClient.delete('/test/1'); + + expect(mockAxios.request).toHaveBeenCalledWith({ method: 'DELETE', url: '/test/1' }); + expect(result).toEqual(mockData); + }); + + it('应该能够发送PATCH请求', async () => { + const mockData = { id: 1, name: 'Patched Test' }; + const requestData = { name: 'Patched Item' }; + mockAxios.request.mockResolvedValue(createMockAxiosResponse(mockData)); + + const result = await apiClient.patch('/test/1', requestData); + + expect(mockAxios.request).toHaveBeenCalledWith({ method: 'PATCH', url: '/test/1', data: requestData }); + expect(result).toEqual(mockData); + }); + + it('应该能够发送通用请求', async () => { + const mockData = { id: 1, name: 'Test' }; + const config = createMockApiRequestConfig({ url: '/test', method: 'GET' }); + mockAxios.request.mockResolvedValue(createMockAxiosResponse(mockData)); + + const result = await apiClient.request(config); + + expect(mockAxios.request).toHaveBeenCalledWith(config); + expect(result).toEqual(mockData); + }); + }); + + describe('返回完整响应的请求方法', () => { + it('应该能够返回GET请求的完整响应', async () => { + const mockData = { id: 1, name: 'Test' }; + const mockResponse = createMockAxiosResponse(mockData); + mockAxios.request.mockResolvedValue(mockResponse); + + const result = await apiClient.request({ url: '/test', method: 'GET' }); + + expect(mockAxios.request).toHaveBeenCalled(); + expect(result).toEqual(mockData); + }); + + it('应该能够返回POST请求的完整响应', async () => { + const mockData = { id: 1, name: 'Test' }; + const requestData = { name: 'New Item' }; + const mockResponse = createMockAxiosResponse(mockData); + mockAxios.request.mockResolvedValue(mockResponse); + + const result = await apiClient.request({ url: '/test', method: 'POST', data: requestData }); + + expect(mockAxios.request).toHaveBeenCalled(); + expect(result).toEqual(mockData); + }); + }); + + describe('拦截器管理', () => { + it('应该能够添加请求拦截器', () => { + const onRequest = (config: any) => config; + const onRequestError = (error: any) => error; + + const interceptorId = apiClient.addRequestInterceptor(onRequest, onRequestError); + + expect(mockAxios.interceptors.request.use).toHaveBeenCalled(); + expect(typeof interceptorId).toBe('number'); + }); + + it('应该能够添加响应拦截器', () => { + const onResponse = (response: any) => response; + const onResponseError = (error: any) => error; + + const interceptorId = apiClient.addResponseInterceptor(onResponse, onResponseError); + + expect(mockAxios.interceptors.response.use).toHaveBeenCalled(); + expect(typeof interceptorId).toBe('number'); + }); + + it('应该能够移除请求拦截器', () => { + const onRequest = (config: any) => config; + + const interceptorId = apiClient.addRequestInterceptor(onRequest); + apiClient.removeRequestInterceptor(interceptorId); + + expect(mockAxios.interceptors.request.eject).toHaveBeenCalledWith(interceptorId); + }); + + it('应该能够处理移除不存在的请求拦截器', () => { + const nonExistentId = 999; + + // 不应该抛出错误 + expect(() => { + apiClient.removeRequestInterceptor(nonExistentId); + }).not.toThrow(); + + // 不应该调用eject方法，因为拦截器不存在 + expect(mockAxios.interceptors.request.eject).not.toHaveBeenCalledWith(nonExistentId); + }); + + it('应该能够移除响应拦截器', () => { + const onResponse = (response: any) => response; + + const interceptorId = apiClient.addResponseInterceptor(onResponse); + apiClient.removeResponseInterceptor(interceptorId); + + expect(mockAxios.interceptors.response.eject).toHaveBeenCalledWith(interceptorId); + }); + + it('应该能够处理移除不存在的响应拦截器', () => { + const nonExistentId = 999; + + // 不应该抛出错误 + expect(() => { + apiClient.removeResponseInterceptor(nonExistentId); + }).not.toThrow(); + + // 不应该调用eject方法，因为拦截器不存在 + expect(mockAxios.interceptors.response.eject).not.toHaveBeenCalledWith(nonExistentId); + }); + + it('应该能够添加和移除多个请求拦截器', () => { + const onRequest1 = (config: any) => config; + const onRequest2 = (config: any) => config; + const onRequest3 = (config: any) => config; + + // 添加三个拦截器 + const id1 = apiClient.addRequestInterceptor(onRequest1); + const id2 = apiClient.addRequestInterceptor(onRequest2); + const id3 = apiClient.addRequestInterceptor(onRequest3); + + // 移除中间的拦截器 + apiClient.removeRequestInterceptor(id2); + + // 验证eject被调用 + expect(mockAxios.interceptors.request.eject).toHaveBeenCalledWith(id2); + + // 移除剩余的拦截器 + apiClient.removeRequestInterceptor(id1); + apiClient.removeRequestInterceptor(id3); + + // 验证所有eject都被调用 + expect(mockAxios.interceptors.request.eject).toHaveBeenCalledWith(id1); + expect(mockAxios.interceptors.request.eject).toHaveBeenCalledWith(id3); + }); + + it('应该能够添加和移除多个响应拦截器', () => { + const onResponse1 = (response: any) => response; + const onResponse2 = (response: any) => response; + const onResponse3 = (response: any) => response; + + // 添加三个拦截器 + const id1 = apiClient.addResponseInterceptor(onResponse1); + const id2 = apiClient.addResponseInterceptor(onResponse2); + const id3 = apiClient.addResponseInterceptor(onResponse3); + + // 移除第一个和第三个拦截器 + apiClient.removeResponseInterceptor(id1); + apiClient.removeResponseInterceptor(id3); + + // 验证eject被调用 + expect(mockAxios.interceptors.response.eject).toHaveBeenCalledWith(id1); + expect(mockAxios.interceptors.response.eject).toHaveBeenCalledWith(id3); + + // 移除剩余的拦截器 + apiClient.removeResponseInterceptor(id2); + + // 验证所有eject都被调用 + expect(mockAxios.interceptors.response.eject).toHaveBeenCalledWith(id2); + }); + }); + + describe('配置管理', () => { + it('应该能够设置默认配置', () => { + const config = { timeout: 5000 }; + apiClient.setDefaults(config); + + expect(mockAxios.defaults.timeout).toBe(5000); + }); + + it('应该能够设置基础URL', () => { + const baseURL = 'https://api.example.com'; + apiClient.setBaseURL(baseURL); + + expect(mockAxios.defaults.baseURL).toBe(baseURL); + }); + }); + + describe('实例创建', () => { + it('应该能够创建新实例', () => { + const newConfig = { timeout: 8000 }; + const newInstance = apiClient.createInstance(newConfig); + + expect(newInstance).toBeDefined(); + expect(typeof newInstance.get).toBe('function'); + expect(typeof newInstance.post).toBe('function'); + }); + + it('应该能够复制拦截器到新实例', () => { + // 添加请求拦截器 + const onRequest = (config: any) => ({ ...config, intercepted: true }); + const onRequestError = (error: any) => error; + const requestInterceptorId = apiClient.addRequestInterceptor(onRequest, onRequestError); + + // 添加响应拦截器 + const onResponse = (response: any) => ({ ...response, intercepted: true }); + const onResponseError = (error: any) => error; + const responseInterceptorId = apiClient.addResponseInterceptor(onResponse, onResponseError); + + // 创建新实例 + const newInstance = apiClient.createInstance({ timeout: 5000 }); + + // 验证新实例有拦截器方法 + expect(typeof newInstance.addRequestInterceptor).toBe('function'); + expect(typeof newInstance.addResponseInterceptor).toBe('function'); + expect(typeof newInstance.removeRequestInterceptor).toBe('function'); + expect(typeof newInstance.removeResponseInterceptor).toBe('function'); + + // 清理 + apiClient.removeRequestInterceptor(requestInterceptorId); + apiClient.removeResponseInterceptor(responseInterceptorId); + }); + + it('应该能够处理headers类型转换', () => { + // 设置原始实例的headers + apiClient.setDefaults({ + headers: { + 'Content-Type': 'application/json', + 'X-Custom-Header': 'custom-value', + 'X-Number-Header': 123, + 'X-Boolean-Header': true, + 'X-Object-Header': { key: 'value' }, // 这个应该被过滤掉 + 'X-Function-Header': () => {} // 这个应该被过滤掉 + } + }); + + // 创建新实例 + const newInstance = apiClient.createInstance({ timeout: 5000 }); + + // 验证新实例创建成功 + expect(newInstance).toBeDefined(); + }); + + it('应该能够创建嵌套实例', () => { + // 创建第一层新实例 + const firstLevelInstance = apiClient.createInstance({ timeout: 3000 }); + + // 从第一层实例创建第二层实例 + const secondLevelInstance = firstLevelInstance.createInstance({ baseURL: 'https://api.example.com' }); + + // 验证第二层实例创建成功 + expect(secondLevelInstance).toBeDefined(); + expect(typeof secondLevelInstance.get).toBe('function'); + expect(typeof secondLevelInstance.post).toBe('function'); + }); + + it('应该能够处理空配置创建实例', () => { + const newInstance = apiClient.createInstance(); + + expect(newInstance).toBeDefined(); + expect(typeof newInstance.get).toBe('function'); + expect(typeof newInstance.post).toBe('function'); + }); + + it('应该能够处理没有headers的实例', () => { + // 创建一个没有headers的实例 + const noHeadersInstance = apiClient.createInstance({ timeout: 2000 }); + + // 从没有headers的实例创建新实例 + const newInstance = noHeadersInstance.createInstance({ baseURL: 'https://test.api.com' }); + + expect(newInstance).toBeDefined(); + }); + }); + + describe('错误处理', () => { + it('应该能够处理请求错误', async () => { + const errorMessage = 'Request failed'; + mockAxios.request.mockRejectedValue(createMockAxiosError(errorMessage)); + + await expect(apiClient.get('/test')).rejects.toThrow(errorMessage); + }); + + it('应该能够处理网络错误', async () => { + const networkError = new Error('Network Error'); + mockAxios.request.mockRejectedValue(networkError); + + await expect(apiClient.get('/test')).rejects.toThrow('Network Error'); + }); + }); + + describe('类型转换', () => { + it('应该正确处理请求配置转换', async () => { + const config = createMockApiRequestConfig({ + url: '/test', + method: 'POST', + data: { name: 'Test' }, + headers: { 'Custom-Header': 'value' } + }); + + const mockData = { success: true }; + mockAxios.request.mockResolvedValue(createMockAxiosResponse(mockData)); + + await apiClient.request(config); + + // 验证axios被调用时接收到了正确的配置 + expect(mockAxios.request).toHaveBeenCalled(); + }); + + it('应该正确处理响应数据转换', async () => { + const mockData = { id: 1, name: 'Test' }; + mockAxios.request.mockResolvedValue(createMockAxiosResponse(mockData)); + + const result = await apiClient.get('/test'); + + // 验证返回的数据是正确的 + expect(result).toEqual(mockData); + }); + }); +}); diff --git a/test/unit/api/modules/chat.test.ts b/test/unit/api/modules/chat.test.ts new file mode 100644 index 0000000..2e83727 --- /dev/null +++ b/test/unit/api/modules/chat.test.ts @@ -0,0 +1,345 @@ +/** + * 聊天API模块测试 + * 测试聊天相关的API调用，包括创建/更新聊天会话、发送消息、获取聊天会话列表、获取聊天消息、标记消息已读等功能 + */ + +import { describe, it, expect, vi, beforeEach } from 'vitest'; +import { chatApi } from '@/api/modules/chat'; +import { createMockAxios } from '@/test/mocks/http-client'; +import { + createMockChatSession, + createMockChatMessage, + createMockUser +} from '@/test/mocks/data-factory'; +import type { ApiClient } from '@/api/client'; +import type { + CreateChatSessionRequest, + UpdateChatSessionRequest, + SendMessageRequest, + GetChatSessionsRequest, + GetChatSessionsResponse, + GetChatMessagesRequest, + GetChatMessagesResponse, + MarkMessagesAsReadRequest, + MarkMessagesAsReadResponse +} from '@/types/chat/api'; + +describe('聊天API模块', () => { + let mockClient: ApiClient; + let chatApiInstance: ReturnType; + + beforeEach(() => { + // 创建模拟的API客户端 + mockClient = { + get: vi.fn(), + post: vi.fn(), + put: vi.fn(), + delete: vi.fn(), + patch: vi.fn(), + request: vi.fn(), + getWithResponse: vi.fn(), + postWithResponse: vi.fn(), + putWithResponse: vi.fn(), + deleteWithResponse: vi.fn(), + patchWithResponse: vi.fn(), + requestWithResponse: vi.fn(), + addRequestInterceptor: vi.fn(), + addResponseInterceptor: vi.fn(), + removeRequestInterceptor: vi.fn(), + removeResponseInterceptor: vi.fn(), + setDefaults: vi.fn(), + setBaseURL: vi.fn(), + createInstance: vi.fn(), + } as unknown as ApiClient; + + // 创建聊天API实例 + chatApiInstance = chatApi(mockClient); + }); + + describe('创建聊天会话功能', () => { + it('应该能够创建新的聊天会话', async () => { + const createRequest: CreateChatSessionRequest = { + title: '测试聊天会话', + modelId: 'model-123', + systemPrompt: '你是一个有用的助手' + }; + const mockSession = createMockChatSession({ + title: createRequest.title, + modelId: createRequest.modelId + }); + const mockResponse = { session: mockSession }; + + mockClient.post.mockResolvedValue(mockResponse); + + const result = await chatApiInstance.createSession(createRequest); + + expect(mockClient.post).toHaveBeenCalledWith('/chat/sessions', createRequest); + expect(result).toEqual(mockResponse); + }); + + it('应该处理创建聊天会话失败的情况', async () => { + const createRequest: CreateChatSessionRequest = { + title: '', + modelId: '', + systemPrompt: '' + }; + const errorResponse = { + success: false, + data: null, + message: '标题和模型ID不能为空', + code: 400 + }; + + mockClient.post.mockRejectedValue(errorResponse); + + await expect(chatApiInstance.createSession(createRequest)).rejects.toEqual(errorResponse); + expect(mockClient.post).toHaveBeenCalledWith('/chat/sessions', createRequest); + }); + }); + + describe('更新聊天会话功能', () => { + it('应该能够更新聊天会话', async () => { + const updateRequest: UpdateChatSessionRequest = { + sessionId: 'session-123', + title: '更新后的标题' + }; + const mockSession = createMockChatSession({ + id: updateRequest.sessionId, + title: updateRequest.title + }); + const mockResponse = { session: mockSession }; + + mockClient.put.mockResolvedValue(mockResponse); + + const result = await chatApiInstance.updateSession(updateRequest); + + expect(mockClient.put).toHaveBeenCalledWith('/chat/sessions/session-123', { title: '更新后的标题' }); + expect(result).toEqual(mockResponse); + }); + + it('应该处理更新不存在会话的情况', async () => { + const updateRequest: UpdateChatSessionRequest = { + sessionId: 'non-existent-session', + title: '更新后的标题' + }; + const errorResponse = { + success: false, + data: null, + message: '会话不存在', + code: 404 + }; + + mockClient.put.mockRejectedValue(errorResponse); + + await expect(chatApiInstance.updateSession(updateRequest)).rejects.toEqual(errorResponse); + expect(mockClient.put).toHaveBeenCalledWith('/chat/sessions/non-existent-session', { title: '更新后的标题' }); + }); + }); + + describe('发送消息功能', () => { + it('应该能够发送消息', async () => { + const sendMessageRequest: SendMessageRequest = { + sessionId: 'session-123', + content: '这是一条测试消息', + role: 'user' + }; + const mockMessage = createMockChatMessage({ + sessionId: sendMessageRequest.sessionId, + content: sendMessageRequest.content, + role: sendMessageRequest.role + }); + const mockResponse = { message: mockMessage }; + + mockClient.post.mockResolvedValue(mockResponse); + + const result = await chatApiInstance.sendMessage(sendMessageRequest); + + expect(mockClient.post).toHaveBeenCalledWith('/chat/sessions/session-123/messages', sendMessageRequest); + expect(result).toEqual(mockResponse); + }); + + it('应该处理发送消息失败的情况', async () => { + const sendMessageRequest: SendMessageRequest = { + sessionId: 'session-123', + content: '', + role: 'user' + }; + const errorResponse = { + success: false, + data: null, + message: '消息内容不能为空', + code: 400 + }; + + mockClient.post.mockRejectedValue(errorResponse); + + await expect(chatApiInstance.sendMessage(sendMessageRequest)).rejects.toEqual(errorResponse); + expect(mockClient.post).toHaveBeenCalledWith('/chat/sessions/session-123/messages', sendMessageRequest); + }); + }); + + describe('获取聊天会话列表功能', () => { + it('应该能够获取聊天会话列表', async () => { + const getRequest: GetChatSessionsRequest = { + page: 1, + limit: 10 + }; + const mockSessions = [ + createMockChatSession({ id: 'session-1' }), + createMockChatSession({ id: 'session-2' }) + ]; + const mockResponse: GetChatSessionsResponse = { + sessions: mockSessions, + pagination: { + page: 1, + limit: 10, + total: 20, + totalPages: 2 + } + }; + + mockClient.get.mockResolvedValue(mockResponse); + + const result = await chatApiInstance.getSessions(getRequest); + + expect(mockClient.get).toHaveBeenCalledWith('/chat/sessions', { params: getRequest }); + expect(result).toEqual(mockResponse); + }); + + it('应该能够在不带参数的情况下获取聊天会话列表', async () => { + const mockSessions = [ + createMockChatSession({ id: 'session-1' }), + createMockChatSession({ id: 'session-2' }) + ]; + const mockResponse: GetChatSessionsResponse = { + sessions: mockSessions, + pagination: { + page: 1, + limit: 20, + total: 2, + totalPages: 1 + } + }; + + mockClient.get.mockResolvedValue(mockResponse); + + const result = await chatApiInstance.getSessions(); + + expect(mockClient.get).toHaveBeenCalledWith('/chat/sessions', {}); + expect(result).toEqual(mockResponse); + }); + + it('应该处理获取聊天会话列表失败的情况', async () => { + const getRequest: GetChatSessionsRequest = { + page: -1, // 无效的页码 + limit: 10 + }; + const errorResponse = { + success: false, + data: null, + message: '页码必须大于0', + code: 400 + }; + + mockClient.get.mockRejectedValue(errorResponse); + + await expect(chatApiInstance.getSessions(getRequest)).rejects.toEqual(errorResponse); + expect(mockClient.get).toHaveBeenCalledWith('/chat/sessions', { params: getRequest }); + }); + }); + + describe('获取聊天消息功能', () => { + it('应该能够获取聊天消息', async () => { + const getRequest: GetChatMessagesRequest = { + sessionId: 'session-123', + page: 1, + limit: 10 + }; + const mockMessages = [ + createMockChatMessage({ id: 'message-1', sessionId: 'session-123' }), + createMockChatMessage({ id: 'message-2', sessionId: 'session-123' }) + ]; + const mockResponse: GetChatMessagesResponse = { + messages: mockMessages, + pagination: { + page: 1, + limit: 10, + total: 30, + totalPages: 3 + } + }; + + mockClient.get.mockResolvedValue(mockResponse); + + const result = await chatApiInstance.getMessages(getRequest); + + expect(mockClient.get).toHaveBeenCalledWith('/chat/sessions/session-123/messages', { + params: { page: 1, limit: 10 } + }); + expect(result).toEqual(mockResponse); + }); + + it('应该处理获取不存在会话的消息的情况', async () => { + const getRequest: GetChatMessagesRequest = { + sessionId: 'non-existent-session', + page: 1, + limit: 10 + }; + const errorResponse = { + success: false, + data: null, + message: '会话不存在', + code: 404 + }; + + mockClient.get.mockRejectedValue(errorResponse); + + await expect(chatApiInstance.getMessages(getRequest)).rejects.toEqual(errorResponse); + expect(mockClient.get).toHaveBeenCalledWith('/chat/sessions/non-existent-session/messages', { + params: { page: 1, limit: 10 } + }); + }); + }); + + describe('标记消息已读功能', () => { + it('应该能够标记消息为已读', async () => { + const markReadRequest: MarkMessagesAsReadRequest = { + sessionId: 'session-123', + messageIds: ['message-1', 'message-2', 'message-3'] + }; + const mockResponse: MarkMessagesAsReadResponse = { + success: true, + readCount: 3 + }; + + mockClient.post.mockResolvedValue(mockResponse); + + const result = await chatApiInstance.markMessagesAsRead(markReadRequest); + + expect(mockClient.post).toHaveBeenCalledWith('/chat/sessions/session-123/read', { + messageIds: ['message-1', 'message-2', 'message-3'] + }); + expect(result).toEqual(mockResponse); + }); + + it('应该处理标记不存在的消息为已读的情况', async () => { + const markReadRequest: MarkMessagesAsReadRequest = { + sessionId: 'session-123', + messageIds: ['non-existent-message'] + }; + const errorResponse = { + success: false, + data: null, + message: '消息不存在', + code: 404 + }; + + mockClient.post.mockRejectedValue(errorResponse); + + await expect(chatApiInstance.markMessagesAsRead(markReadRequest)).rejects.toEqual(errorResponse); + expect(mockClient.post).toHaveBeenCalledWith('/chat/sessions/session-123/read', { + messageIds: ['non-existent-message'] + }); + }); + }); +}); \ No newline at end of file diff --git a/test/unit/api/modules/model.test.ts b/test/unit/api/modules/model.test.ts new file mode 100644 index 0000000..82b96d3 --- /dev/null +++ b/test/unit/api/modules/model.test.ts @@ -0,0 +1,239 @@ +/** + * AI模型API模块测试 + * 测试AI模型相关的API调用，包括获取AI模型广场、获取模型详情、获取模型评论等功能 + */ + +import { describe, it, expect, vi, beforeEach } from 'vitest'; +import { modelApi } from '@/api/modules/model'; +import { createMockAxios } from '@/test/mocks/http-client'; +import { + createMockAIModel, + createMockModelComment, + createMockUser +} from '@/test/mocks/data-factory'; +import type { ApiClient } from '@/api/client'; +import type { + GetAIPlazaRequest, + GetAIPlazaResponse, + GetModelDetailRequest, + GetModelDetailResponse, + GetModelCommentsRequest, + GetModelCommentsResponse +} from '@/types/model/api'; + +describe('AI模型API模块', () => { + let mockClient: ApiClient; + let modelApiInstance: ReturnType; + + beforeEach(() => { + // 创建模拟的API客户端 + mockClient = { + get: vi.fn(), + post: vi.fn(), + put: vi.fn(), + delete: vi.fn(), + patch: vi.fn(), + request: vi.fn(), + getWithResponse: vi.fn(), + postWithResponse: vi.fn(), + putWithResponse: vi.fn(), + deleteWithResponse: vi.fn(), + patchWithResponse: vi.fn(), + requestWithResponse: vi.fn(), + addRequestInterceptor: vi.fn(), + addResponseInterceptor: vi.fn(), + removeRequestInterceptor: vi.fn(), + removeResponseInterceptor: vi.fn(), + setDefaults: vi.fn(), + setBaseURL: vi.fn(), + createInstance: vi.fn(), + } as unknown as ApiClient; + + // 创建AI模型API实例 + modelApiInstance = modelApi(mockClient); + }); + + describe('获取AI模型广场功能', () => { + it('应该能够获取AI模型广场数据', async () => { + const getRequest: GetAIPlazaRequest = { + page: 1, + limit: 10, + category: 'text-generation' + }; + const mockModels = [ + createMockAIModel({ id: 'model-1', category: 'text-generation' }), + createMockAIModel({ id: 'model-2', category: 'text-generation' }) + ]; + const mockResponse: GetAIPlazaResponse = { + models: mockModels, + categories: [ + { id: 'text-generation', name: '文本生成', count: 50 }, + { id: 'image-generation', name: '图像生成', count: 30 } + ], + pagination: { + page: 1, + limit: 10, + total: 50, + totalPages: 5 + } + }; + + mockClient.get.mockResolvedValue(mockResponse); + + const result = await modelApiInstance.getAIPlaza(getRequest); + + expect(mockClient.get).toHaveBeenCalledWith('/models/plaza', { params: getRequest }); + expect(result).toEqual(mockResponse); + }); + + it('应该能够在不带参数的情况下获取AI模型广场数据', async () => { + const mockModels = [ + createMockAIModel({ id: 'model-1' }), + createMockAIModel({ id: 'model-2' }) + ]; + const mockResponse: GetAIPlazaResponse = { + models: mockModels, + categories: [ + { id: 'text-generation', name: '文本生成', count: 50 }, + { id: 'image-generation', name: '图像生成', count: 30 } + ], + pagination: { + page: 1, + limit: 20, + total: 2, + totalPages: 1 + } + }; + + mockClient.get.mockResolvedValue(mockResponse); + + const result = await modelApiInstance.getAIPlaza(); + + expect(mockClient.get).toHaveBeenCalledWith('/models/plaza', {}); + expect(result).toEqual(mockResponse); + }); + + it('应该处理获取AI模型广场失败的情况', async () => { + const getRequest: GetAIPlazaRequest = { + page: -1, // 无效的页码 + limit: 10 + }; + const errorResponse = { + success: false, + data: null, + message: '页码必须大于0', + code: 400 + }; + + mockClient.get.mockRejectedValue(errorResponse); + + await expect(modelApiInstance.getAIPlaza(getRequest)).rejects.toEqual(errorResponse); + expect(mockClient.get).toHaveBeenCalledWith('/models/plaza', { params: getRequest }); + }); + }); + + describe('获取模型详情功能', () => { + it('应该能够获取模型详情', async () => { + const getRequest: GetModelDetailRequest = { + modelId: 'model-123' + }; + const mockModel = createMockAIModel({ id: 'model-123' }); + const mockResponse: GetModelDetailResponse = { + model: mockModel, + relatedModels: [ + createMockAIModel({ id: 'related-1' }), + createMockAIModel({ id: 'related-2' }) + ] + }; + + mockClient.get.mockResolvedValue(mockResponse); + + const result = await modelApiInstance.getModelDetail(getRequest); + + expect(mockClient.get).toHaveBeenCalledWith('/models/model-123', { params: {} }); + expect(result).toEqual(mockResponse); + }); + + it('应该处理获取不存在模型详情的情况', async () => { + const getRequest: GetModelDetailRequest = { + modelId: 'non-existent-model' + }; + const errorResponse = { + success: false, + data: null, + message: '模型不存在', + code: 404 + }; + + mockClient.get.mockRejectedValue(errorResponse); + + await expect(modelApiInstance.getModelDetail(getRequest)).rejects.toEqual(errorResponse); + expect(mockClient.get).toHaveBeenCalledWith('/models/non-existent-model', { params: {} }); + }); + }); + + describe('获取模型评论功能', () => { + it('应该能够获取模型评论', async () => { + const getRequest: GetModelCommentsRequest = { + modelId: 'model-123', + page: 1, + limit: 10, + sortBy: 'newest' + }; + const mockComments = [ + createMockModelComment({ id: 'comment-1', modelId: 'model-123' }), + createMockModelComment({ id: 'comment-2', modelId: 'model-123' }) + ]; + const mockResponse: GetModelCommentsResponse = { + comments: mockComments, + pagination: { + page: 1, + limit: 10, + total: 25, + totalPages: 3 + }, + statistics: { + averageRating: 4.5, + totalComments: 25, + ratingDistribution: { + 5: 15, + 4: 7, + 3: 2, + 2: 1, + 1: 0 + } + } + }; + + mockClient.get.mockResolvedValue(mockResponse); + + const result = await modelApiInstance.getModelComments(getRequest); + + expect(mockClient.get).toHaveBeenCalledWith('/models/model-123/comments', { + params: { page: 1, limit: 10, sortBy: 'newest' } + }); + expect(result).toEqual(mockResponse); + }); + + it('应该处理获取不存在模型的评论的情况', async () => { + const getRequest: GetModelCommentsRequest = { + modelId: 'non-existent-model', + page: 1, + limit: 10 + }; + const errorResponse = { + success: false, + data: null, + message: '模型不存在', + code: 404 + }; + + mockClient.get.mockRejectedValue(errorResponse); + + await expect(modelApiInstance.getModelComments(getRequest)).rejects.toEqual(errorResponse); + expect(mockClient.get).toHaveBeenCalledWith('/models/non-existent-model/comments', { + params: { page: 1, limit: 10 } + }); + }); + }); +}); \ No newline at end of file diff --git a/test/unit/api/modules/post.test.ts b/test/unit/api/modules/post.test.ts new file mode 100644 index 0000000..17d0ae6 --- /dev/null +++ b/test/unit/api/modules/post.test.ts @@ -0,0 +1,408 @@ +/** + * 帖子API模块测试 + * 测试帖子相关的API调用，包括创建帖子、获取帖子列表、点赞、评论等功能 + */ + +import { describe, it, expect, vi, beforeEach } from 'vitest'; +import { postApi } from '@/api/modules/post'; +import { createMockAxios } from '@/test/mocks/http-client'; +import { + createMockPost, + createMockUser, + createMockPostComment +} from '@/test/mocks/data-factory'; +import type { ApiClient } from '@/api/client'; +import type { + CreatePostRequest, + CreatePostResponse, + GetPostsRequest, + GetPostsResponse, + GetPostRequest, + GetPostResponse, + LikePostRequest, + LikePostResponse, + BookmarkPostRequest, + BookmarkPostResponse, + CreateCommentRequest, + CreateCommentResponse, + GetCommentsRequest, + GetCommentsResponse, + LikeCommentRequest, + LikeCommentResponse +} from '@/types/post/api'; + +describe('帖子API模块', () => { + let mockClient: ApiClient; + let postApiInstance: ReturnType; + + beforeEach(() => { + // 创建模拟的API客户端 + mockClient = { + get: vi.fn(), + post: vi.fn(), + put: vi.fn(), + delete: vi.fn(), + patch: vi.fn(), + request: vi.fn(), + getWithResponse: vi.fn(), + postWithResponse: vi.fn(), + putWithResponse: vi.fn(), + deleteWithResponse: vi.fn(), + patchWithResponse: vi.fn(), + requestWithResponse: vi.fn(), + addRequestInterceptor: vi.fn(), + addResponseInterceptor: vi.fn(), + removeRequestInterceptor: vi.fn(), + removeResponseInterceptor: vi.fn(), + setDefaults: vi.fn(), + setBaseURL: vi.fn(), + createInstance: vi.fn(), + } as unknown as ApiClient; + + // 创建帖子API实例 + postApiInstance = postApi(mockClient); + }); + + describe('创建帖子功能', () => { + it('应该能够创建新帖子', async () => { + const createRequest: CreatePostRequest = { + title: '测试帖子标题', + content: '这是一个测试帖子的内容', + tags: ['测试', 'API'], + isPublic: true + }; + const mockPost = createMockPost({ + title: createRequest.title, + content: createRequest.content, + tags: createRequest.tags + }); + const mockResponse: CreatePostResponse = { + success: true, + data: mockPost, + message: '帖子创建成功', + code: 201 + }; + + mockClient.post.mockResolvedValue(mockResponse); + + const result = await postApiInstance.createPost(createRequest); + + expect(mockClient.post).toHaveBeenCalledWith('/posts', createRequest); + expect(result).toEqual(mockResponse); + }); + + it('应该处理创建帖子失败的情况', async () => { + const createRequest: CreatePostRequest = { + title: '', + content: '', + tags: [], + isPublic: true + }; + const errorResponse = { + success: false, + data: null, + message: '标题和内容不能为空', + code: 400 + }; + + mockClient.post.mockRejectedValue(errorResponse); + + await expect(postApiInstance.createPost(createRequest)).rejects.toEqual(errorResponse); + expect(mockClient.post).toHaveBeenCalledWith('/posts', createRequest); + }); + }); + + describe('获取帖子列表功能', () => { + it('应该能够获取帖子列表', async () => { + const getRequest: GetPostsRequest = { + page: 1, + limit: 10, + tag: '测试' + }; + const mockPosts = [ + createMockPost({ id: 'post-1' }), + createMockPost({ id: 'post-2' }) + ]; + const mockResponse: GetPostsResponse = { + success: true, + data: { + posts: mockPosts, + pagination: { + page: 1, + limit: 10, + total: 100, + totalPages: 10 + } + }, + message: '获取帖子列表成功', + code: 200 + }; + + mockClient.get.mockResolvedValue(mockResponse); + + const result = await postApiInstance.getPosts(getRequest); + + expect(mockClient.get).toHaveBeenCalledWith('/posts', { params: getRequest }); + expect(result).toEqual(mockResponse); + }); + + it('应该处理获取帖子列表失败的情况', async () => { + const getRequest: GetPostsRequest = { + page: -1, // 无效的页码 + limit: 10 + }; + const errorResponse = { + success: false, + data: null, + message: '页码必须大于0', + code: 400 + }; + + mockClient.get.mockRejectedValue(errorResponse); + + await expect(postApiInstance.getPosts(getRequest)).rejects.toEqual(errorResponse); + expect(mockClient.get).toHaveBeenCalledWith('/posts', { params: getRequest }); + }); + }); + + describe('获取帖子详情功能', () => { + it('应该能够获取帖子详情', async () => { + const getRequest: GetPostRequest = { postId: 'post-123' }; + const mockPost = createMockPost({ id: 'post-123' }); + const mockResponse: GetPostResponse = { + success: true, + data: mockPost, + message: '获取帖子详情成功', + code: 200 + }; + + mockClient.get.mockResolvedValue(mockResponse); + + const result = await postApiInstance.getPost(getRequest); + + expect(mockClient.get).toHaveBeenCalledWith('/posts/post-123'); + expect(result).toEqual(mockResponse); + }); + + it('应该处理获取不存在帖子的情况', async () => { + const getRequest: GetPostRequest = { postId: 'non-existent-post' }; + const errorResponse = { + success: false, + data: null, + message: '帖子不存在', + code: 404 + }; + + mockClient.get.mockRejectedValue(errorResponse); + + await expect(postApiInstance.getPost(getRequest)).rejects.toEqual(errorResponse); + expect(mockClient.get).toHaveBeenCalledWith('/posts/non-existent-post'); + }); + }); + + describe('点赞帖子功能', () => { + it('应该能够点赞帖子', async () => { + const likeRequest: LikePostRequest = { postId: 'post-123' }; + const mockResponse: LikePostResponse = { + success: true, + message: '点赞成功', + code: 200 + }; + + mockClient.put.mockResolvedValue(mockResponse); + + const result = await postApiInstance.likePost(likeRequest); + + expect(mockClient.put).toHaveBeenCalledWith('/posts/post-123/like'); + expect(result).toEqual(mockResponse); + }); + + it('应该处理点赞不存在帖子的情况', async () => { + const likeRequest: LikePostRequest = { postId: 'non-existent-post' }; + const errorResponse = { + success: false, + data: null, + message: '帖子不存在', + code: 404 + }; + + mockClient.put.mockRejectedValue(errorResponse); + + await expect(postApiInstance.likePost(likeRequest)).rejects.toEqual(errorResponse); + expect(mockClient.put).toHaveBeenCalledWith('/posts/non-existent-post/like'); + }); + }); + + describe('收藏帖子功能', () => { + it('应该能够收藏帖子', async () => { + const bookmarkRequest: BookmarkPostRequest = { postId: 'post-123' }; + const mockResponse: BookmarkPostResponse = { + success: true, + message: '收藏成功', + code: 200 + }; + + mockClient.put.mockResolvedValue(mockResponse); + + const result = await postApiInstance.bookmarkPost(bookmarkRequest); + + expect(mockClient.put).toHaveBeenCalledWith('/posts/post-123/bookmark'); + expect(result).toEqual(mockResponse); + }); + + it('应该处理收藏不存在帖子的情况', async () => { + const bookmarkRequest: BookmarkPostRequest = { postId: 'non-existent-post' }; + const errorResponse = { + success: false, + data: null, + message: '帖子不存在', + code: 404 + }; + + mockClient.put.mockRejectedValue(errorResponse); + + await expect(postApiInstance.bookmarkPost(bookmarkRequest)).rejects.toEqual(errorResponse); + expect(mockClient.put).toHaveBeenCalledWith('/posts/non-existent-post/bookmark'); + }); + }); + + describe('创建评论功能', () => { + it('应该能够创建评论', async () => { + const commentRequest: CreateCommentRequest = { + postId: 'post-123', + content: '这是一个测试评论', + parentId: 'parent-comment-123' + }; + const mockComment = createMockPostComment({ + postId: commentRequest.postId, + content: commentRequest.content, + parentId: commentRequest.parentId + }); + const mockResponse: CreateCommentResponse = { + success: true, + data: mockComment, + message: '评论创建成功', + code: 201 + }; + + mockClient.post.mockResolvedValue(mockResponse); + + const result = await postApiInstance.createComment(commentRequest); + + expect(mockClient.post).toHaveBeenCalledWith('/posts/post-123/comments', commentRequest); + expect(result).toEqual(mockResponse); + }); + + it('应该处理创建评论失败的情况', async () => { + const commentRequest: CreateCommentRequest = { + postId: 'post-123', + content: '', // 空评论内容 + parentId: 'parent-comment-123' + }; + const errorResponse = { + success: false, + data: null, + message: '评论内容不能为空', + code: 400 + }; + + mockClient.post.mockRejectedValue(errorResponse); + + await expect(postApiInstance.createComment(commentRequest)).rejects.toEqual(errorResponse); + expect(mockClient.post).toHaveBeenCalledWith('/posts/post-123/comments', commentRequest); + }); + }); + + describe('获取评论列表功能', () => { + it('应该能够获取评论列表', async () => { + const commentsRequest: GetCommentsRequest = { + postId: 'post-123', + page: 1, + limit: 10, + sortBy: 'createdAt', + sortOrder: 'desc' + }; + const mockComments = [ + createMockPostComment({ id: 'comment-1', postId: 'post-123' }), + createMockPostComment({ id: 'comment-2', postId: 'post-123' }) + ]; + const mockResponse: GetCommentsResponse = { + success: true, + data: { + comments: mockComments, + pagination: { + page: 1, + limit: 10, + total: 50, + totalPages: 5 + } + }, + message: '获取评论列表成功', + code: 200 + }; + + mockClient.get.mockResolvedValue(mockResponse); + + const result = await postApiInstance.getComments(commentsRequest); + + expect(mockClient.get).toHaveBeenCalledWith('/posts/post-123/comments', { + params: { page: 1, limit: 10, sortBy: 'createdAt', sortOrder: 'desc' } + }); + expect(result).toEqual(mockResponse); + }); + + it('应该处理获取评论列表失败的情况', async () => { + const commentsRequest: GetCommentsRequest = { + postId: 'post-123', + page: -1, // 无效的页码 + limit: 10 + }; + const errorResponse = { + success: false, + data: null, + message: '页码必须大于0', + code: 400 + }; + + mockClient.get.mockRejectedValue(errorResponse); + + await expect(postApiInstance.getComments(commentsRequest)).rejects.toEqual(errorResponse); + expect(mockClient.get).toHaveBeenCalledWith('/posts/post-123/comments', { + params: { page: -1, limit: 10 } + }); + }); + }); + + describe('点赞评论功能', () => { + it('应该能够点赞评论', async () => { + const likeCommentRequest: LikeCommentRequest = { commentId: 'comment-123' }; + const mockResponse: LikeCommentResponse = { + success: true, + message: '点赞评论成功', + code: 200 + }; + + mockClient.put.mockResolvedValue(mockResponse); + + const result = await postApiInstance.likeComment(likeCommentRequest); + + expect(mockClient.put).toHaveBeenCalledWith('/comments/comment-123/like'); + expect(result).toEqual(mockResponse); + }); + + it('应该处理点赞不存在评论的情况', async () => { + const likeCommentRequest: LikeCommentRequest = { commentId: 'non-existent-comment' }; + const errorResponse = { + success: false, + data: null, + message: '评论不存在', + code: 404 + }; + + mockClient.put.mockRejectedValue(errorResponse); + + await expect(postApiInstance.likeComment(likeCommentRequest)).rejects.toEqual(errorResponse); + expect(mockClient.put).toHaveBeenCalledWith('/comments/non-existent-comment/like'); + }); + }); +}) \ No newline at end of file diff --git a/test/unit/api/modules/user.test.ts b/test/unit/api/modules/user.test.ts new file mode 100644 index 0000000..11b0e89 --- /dev/null +++ b/test/unit/api/modules/user.test.ts @@ -0,0 +1,334 @@ +/** + * 用户API模块测试 + * 测试用户相关的API调用，包括登录、注册、刷新令牌、获取/更新用户档案、关注/取消关注用户等功能 + */ + +import { describe, it, expect, vi, beforeEach } from 'vitest'; +import { userApi } from '@/api/modules/user'; +import { createMockAxios } from '@/test/mocks/http-client'; +import { + createMockUser, + createMockUserProfile +} from '@/test/mocks/data-factory'; +import type { ApiClient } from '@/api/client'; +import type { + LoginRequest, + LoginResponse, + RegisterRequest, + RegisterResponse, + RefreshTokenRequest, + RefreshTokenResponse, + UserProfileUpdateRequest, + UserProfileUpdateResponse, + UserFollowRequest, + UserFollowResponse +} from '@/types/user'; + +describe('用户API模块', () => { + let mockClient: ApiClient; + let userApiInstance: ReturnType; + + beforeEach(() => { + // 创建模拟的API客户端 + mockClient = { + get: vi.fn(), + post: vi.fn(), + put: vi.fn(), + delete: vi.fn(), + patch: vi.fn(), + request: vi.fn(), + getWithResponse: vi.fn(), + postWithResponse: vi.fn(), + putWithResponse: vi.fn(), + deleteWithResponse: vi.fn(), + patchWithResponse: vi.fn(), + requestWithResponse: vi.fn(), + addRequestInterceptor: vi.fn(), + addResponseInterceptor: vi.fn(), + removeRequestInterceptor: vi.fn(), + removeResponseInterceptor: vi.fn(), + setDefaults: vi.fn(), + setBaseURL: vi.fn(), + createInstance: vi.fn(), + } as unknown as ApiClient; + + // 创建用户API实例 + userApiInstance = userApi(mockClient); + }); + + describe('用户登录功能', () => { + it('应该能够成功登录', async () => { + const loginRequest: LoginRequest = { + username: 'test@example.com', + password: 'password123' + }; + const mockUser = createMockUser({ username: loginRequest.username }); + const mockResponse: LoginResponse = { + user: mockUser, + sessionId: 'session-123' + }; + + mockClient.post.mockResolvedValue(mockResponse); + + const result = await userApiInstance.login(loginRequest); + + expect(mockClient.post).toHaveBeenCalledWith('/auth/login', loginRequest); + expect(result).toEqual(mockResponse); + }); + + it('应该处理登录失败的情况', async () => { + const loginRequest: LoginRequest = { + username: 'wrong@example.com', + password: 'wrongpassword' + }; + const errorResponse = { + success: false, + data: null, + message: '用户名或密码错误', + code: 401 + }; + + mockClient.post.mockRejectedValue(errorResponse); + + await expect(userApiInstance.login(loginRequest)).rejects.toEqual(errorResponse); + expect(mockClient.post).toHaveBeenCalledWith('/auth/login', loginRequest); + }); + }); + + describe('用户注册功能', () => { + it('应该能够成功注册', async () => { + const registerRequest: RegisterRequest = { + username: 'newuser', + email: 'newuser@example.com', + password: 'password123' + }; + const mockUser = createMockUser({ + username: registerRequest.username, + email: registerRequest.email + }); + const mockResponse: RegisterResponse = { + user: mockUser, + sessionId: 'session-456' + }; + + mockClient.post.mockResolvedValue(mockResponse); + + const result = await userApiInstance.register(registerRequest); + + expect(mockClient.post).toHaveBeenCalledWith('/auth/register', registerRequest); + expect(result).toEqual(mockResponse); + }); + + it('应该处理注册失败的情况', async () => { + const registerRequest: RegisterRequest = { + username: '', + email: 'invalid-email', + password: '123' // 密码太短 + }; + const errorResponse = { + success: false, + data: null, + message: '用户名不能为空，邮箱格式不正确，密码长度至少为6位', + code: 400 + }; + + mockClient.post.mockRejectedValue(errorResponse); + + await expect(userApiInstance.register(registerRequest)).rejects.toEqual(errorResponse); + expect(mockClient.post).toHaveBeenCalledWith('/auth/register', registerRequest); + }); + }); + + describe('刷新令牌功能', () => { + it('应该能够成功刷新令牌', async () => { + const refreshTokenRequest: RefreshTokenRequest = { + sessionId: 'session-456' + }; + const mockResponse: RefreshTokenResponse = { + sessionId: 'new-session-789' + }; + + mockClient.post.mockResolvedValue(mockResponse); + + const result = await userApiInstance.refreshToken(refreshTokenRequest); + + expect(mockClient.post).toHaveBeenCalledWith('/auth/refresh', refreshTokenRequest); + expect(result).toEqual(mockResponse); + }); + + it('应该处理刷新令牌失败的情况', async () => { + const refreshTokenRequest: RefreshTokenRequest = { + sessionId: 'invalid-session' + }; + const errorResponse = { + success: false, + data: null, + message: '会话无效或已过期', + code: 401 + }; + + mockClient.post.mockRejectedValue(errorResponse); + + await expect(userApiInstance.refreshToken(refreshTokenRequest)).rejects.toEqual(errorResponse); + expect(mockClient.post).toHaveBeenCalledWith('/auth/refresh', refreshTokenRequest); + }); + }); + + describe('获取用户档案功能', () => { + it('应该能够获取用户档案', async () => { + const mockUserProfile = createMockUserProfile(); + const mockResponse: UserProfileUpdateResponse = { + success: true, + data: mockUserProfile, + message: '获取用户档案成功', + code: 200 + }; + + mockClient.get.mockResolvedValue(mockResponse); + + const result = await userApiInstance.getProfile(); + + expect(mockClient.get).toHaveBeenCalledWith('/user/profile'); + expect(result).toEqual(mockResponse); + }); + + it('应该处理获取用户档案失败的情况', async () => { + const errorResponse = { + success: false, + data: null, + message: '用户未登录', + code: 401 + }; + + mockClient.get.mockRejectedValue(errorResponse); + + await expect(userApiInstance.getProfile()).rejects.toEqual(errorResponse); + expect(mockClient.get).toHaveBeenCalledWith('/user/profile'); + }); + }); + + describe('更新用户档案功能', () => { + it('应该能够更新用户档案', async () => { + const updateRequest: UserProfileUpdateRequest = { + username: 'updateduser', + bio: '这是我的个人简介', + avatar: 'https://example.com/avatar.jpg' + }; + const mockUserProfile = createMockUserProfile(updateRequest); + const mockResponse: UserProfileUpdateResponse = { + success: true, + data: mockUserProfile, + message: '用户档案更新成功', + code: 200 + }; + + mockClient.put.mockResolvedValue(mockResponse); + + const result = await userApiInstance.updateProfile(updateRequest); + + expect(mockClient.put).toHaveBeenCalledWith('/user/profile', updateRequest); + expect(result).toEqual(mockResponse); + }); + + it('应该处理更新用户档案失败的情况', async () => { + const updateRequest: UserProfileUpdateRequest = { + username: '', // 用户名不能为空 + bio: '', + avatar: '' + }; + const errorResponse = { + success: false, + data: null, + message: '用户名不能为空', + code: 400 + }; + + mockClient.put.mockRejectedValue(errorResponse); + + await expect(userApiInstance.updateProfile(updateRequest)).rejects.toEqual(errorResponse); + expect(mockClient.put).toHaveBeenCalledWith('/user/profile', updateRequest); + }); + }); + + describe('关注用户功能', () => { + it('应该能够关注用户', async () => { + const followRequest: UserFollowRequest = { + userId: 'user-123' + }; + const mockResponse: UserFollowResponse = { + success: true, + data: { + isFollowing: true, + followersCount: 101 + }, + message: '关注成功', + code: 200 + }; + + mockClient.put.mockResolvedValue(mockResponse); + + const result = await userApiInstance.followUser(followRequest); + + expect(mockClient.put).toHaveBeenCalledWith('/user/follow/user-123'); + expect(result).toEqual(mockResponse); + }); + + it('应该处理关注不存在的用户的情况', async () => { + const followRequest: UserFollowRequest = { + userId: 'non-existent-user' + }; + const errorResponse = { + success: false, + data: null, + message: '用户不存在', + code: 404 + }; + + mockClient.put.mockRejectedValue(errorResponse); + + await expect(userApiInstance.followUser(followRequest)).rejects.toEqual(errorResponse); + expect(mockClient.put).toHaveBeenCalledWith('/user/follow/non-existent-user'); + }); + }); + + describe('取消关注用户功能', () => { + it('应该能够取消关注用户', async () => { + const unfollowRequest: UserFollowRequest = { + userId: 'user-123' + }; + const mockResponse: UserFollowResponse = { + success: true, + data: { + isFollowing: false, + followersCount: 99 + }, + message: '取消关注成功', + code: 200 + }; + + mockClient.delete.mockResolvedValue(mockResponse); + + const result = await userApiInstance.unfollowUser(unfollowRequest); + + expect(mockClient.delete).toHaveBeenCalledWith('/user/follow/user-123'); + expect(result).toEqual(mockResponse); + }); + + it('应该处理取消关注不存在的用户的情况', async () => { + const unfollowRequest: UserFollowRequest = { + userId: 'non-existent-user' + }; + const errorResponse = { + success: false, + data: null, + message: '用户不存在', + code: 404 + }; + + mockClient.delete.mockRejectedValue(errorResponse); + + await expect(userApiInstance.unfollowUser(unfollowRequest)).rejects.toEqual(errorResponse); + expect(mockClient.delete).toHaveBeenCalledWith('/user/follow/non-existent-user'); + }); + }); +}); \ No newline at end of file diff --git a/test/unit/auth/auth-service.test.ts b/test/unit/auth/auth-service.test.ts new file mode 100644 index 0000000..a8ec735 --- /dev/null +++ b/test/unit/auth/auth-service.test.ts @@ -0,0 +1,379 @@ +/** + * 认证服务集成测试 + */ + +import { describe, it, expect, beforeEach, vi } from 'vitest'; +import { createAuthService } from '@/auth'; +import { apiClient } from '@/api'; +import { createMockStorage } from '@/test/mocks'; +import type { StorageAdapter } from '@/auth/storage-adapter'; +import type { LoginRequest, LoginResponse, RegisterRequest, RegisterResponse } from '@/types/user/profile'; +import { ApiError } from '@/api/errors'; +import { AuthError } from '@/auth/errors'; + +// 模拟API客户端 +vi.mock('@/api', () => ({ + apiClient: { + addRequestInterceptor: vi.fn(), + addResponseInterceptor: vi.fn(), + removeRequestInterceptor: vi.fn(), + removeResponseInterceptor: vi.fn(), + setDefaults: vi.fn(), + setBaseURL: vi.fn(), + createInstance: vi.fn(), + get: vi.fn(), + post: vi.fn(), + put: vi.fn(), + delete: vi.fn(), + patch: vi.fn(), + request: vi.fn() + } +})); + +// 模拟错误处理 +vi.mock('@/api/errors', () => ({ + isApiError: vi.fn((error: unknown): error is ApiError => + error && typeof error === 'object' && 'isApiError' in error && (error as any).isApiError + ), + ApiError: class extends Error { + public readonly code: number; + public readonly details: unknown; + + constructor(code: number, message: string, details?: unknown) { + super(message); + this.name = 'ApiError'; + this.code = code; + this.details = details; + } + } +})); + +describe('认证服务', () => { + let authService: ReturnType; + let mockStorage: StorageAdapter; + + beforeEach(() => { + mockStorage = createMockStorage(); + authService = createAuthService(apiClient); + vi.clearAllMocks(); + }); + + describe('login', () => { + it('应该成功登录并返回用户信息', async () => { + // 准备测试数据 + const loginData: LoginRequest = { + username: 'testuser', + password: 'password123' + }; + + const loginResponse: LoginResponse = { + user: { + id: '1', + username: 'testuser', + email: 'test@example.com', + avatar: '', + nickname: 'Test User', + bio: '', + createdAt: new Date().toISOString(), + updatedAt: new Date().toISOString() + }, + sessionId: 'test-session-id' + }; + + // 模拟API响应 + (apiClient.post as any).mockResolvedValue(loginResponse); + // 模拟getUserInfo调用 + (apiClient.get as any).mockResolvedValue({ user: loginResponse.user }); + + // 执行登录 + const result = await authService.login(loginData); + + // 验证结果 + expect(result).toEqual(loginResponse); + expect(apiClient.post).toHaveBeenCalledWith('/auth/login', loginData); + expect(apiClient.get).toHaveBeenCalledWith('/auth/me'); + }); + + it('应该处理登录失败', async () => { + // 准备测试数据 + const loginData: LoginRequest = { + username: 'testuser', + password: 'wrongpassword' + }; + + // 创建一个真正的ApiError对象 + const mockApiError = new ApiError(401, '用户名或密码错误', {}); + + // 模拟API错误响应 + (apiClient.post as any).mockRejectedValue(mockApiError); + + // 模拟sessionManager.getUserInfo，确保它不会被调用 + const mockSessionManager = { + getUserInfo: vi.fn() + }; + (authService as any).sessionManager = mockSessionManager; + + // 执行登录并期望失败 + await expect(authService.login(loginData)).rejects.toThrowError( + expect.objectContaining({ + name: 'AuthError', + code: 'LOGIN_FAILED' + }) + ); + expect(apiClient.post).toHaveBeenCalledWith('/auth/login', loginData); + expect(mockSessionManager.getUserInfo).not.toHaveBeenCalled(); + }); + }); + + describe('register', () => { + it('应该成功注册并返回用户信息', async () => { + // 准备测试数据 + const registerData: RegisterRequest = { + username: 'newuser', + email: 'newuser@example.com', + password: 'password123' + }; + + const registerResponse: RegisterResponse = { + user: { + id: '2', + username: 'newuser', + email: 'newuser@example.com', + avatar: '', + nickname: 'New User', + bio: '', + createdAt: new Date().toISOString(), + updatedAt: new Date().toISOString() + }, + sessionId: 'new-session-id' + }; + + // 模拟API响应 + (apiClient.post as any).mockResolvedValue(registerResponse); + // 模拟getUserInfo调用 + (apiClient.get as any).mockResolvedValue({ user: registerResponse.user }); + + // 执行注册 + const result = await authService.register(registerData); + + // 验证结果 + expect(result).toEqual(registerResponse); + expect(apiClient.post).toHaveBeenCalledWith('/auth/register', registerData); + expect(apiClient.get).toHaveBeenCalledWith('/auth/me'); + }); + + it('应该处理注册失败', async () => { + // 准备测试数据 + const registerData: RegisterRequest = { + username: 'existinguser', + email: 'existing@example.com', + password: 'password123' + }; + + // 创建一个真正的ApiError对象 + const mockApiError = new ApiError(409, '用户已存在', {}); + + // 模拟API错误响应 + (apiClient.post as any).mockRejectedValue(mockApiError); + + // 模拟sessionManager.getUserInfo，确保它不会被调用 + const mockSessionManager = { + getUserInfo: vi.fn() + }; + (authService as any).sessionManager = mockSessionManager; + + // 执行注册并期望失败 + await expect(authService.register(registerData)).rejects.toThrowError( + expect.objectContaining({ + name: 'AuthError', + code: 'REGISTER_FAILED' + }) + ); + expect(apiClient.post).toHaveBeenCalledWith('/auth/register', registerData); + expect(mockSessionManager.getUserInfo).not.toHaveBeenCalled(); + }); + }); + + describe('logout', () => { + it('应该调用登出API并清除缓存', async () => { + // 模拟API响应 + (apiClient.post as any).mockResolvedValue({}); + + // 模拟sessionManager.clearCache + const mockSessionManager = { + clearCache: vi.fn() + }; + (authService as any).sessionManager = mockSessionManager; + + // 执行登出 + await authService.logout(); + + // 验证API调用 + expect(apiClient.post).toHaveBeenCalledWith('/auth/logout'); + expect(mockSessionManager.clearCache).toHaveBeenCalledTimes(1); + }); + + it('应该处理登出API失败但仍清除缓存', async () => { + // 模拟API错误 + const apiError = new Error('Network error'); + (apiClient.post as any).mockRejectedValue(apiError); + + // 模拟sessionManager.clearCache + const mockSessionManager = { + clearCache: vi.fn() + }; + (authService as any).sessionManager = mockSessionManager; + + // 执行登出并期望失败 + await expect(authService.logout()).rejects.toThrowError( + expect.objectContaining({ + name: 'AuthError', + code: 'LOGOUT_FAILED' + }) + ); + + // 验证API调用和缓存清除 + expect(apiClient.post).toHaveBeenCalledWith('/auth/logout'); + expect(mockSessionManager.clearCache).toHaveBeenCalledTimes(1); + }); + }); + + describe('isAuthenticated', () => { + it('应该返回认证状态', async () => { + // 模拟sessionManager.isAuthenticated返回true + const mockSessionManager = { + isAuthenticated: vi.fn().mockResolvedValue(true) + }; + + // 通过访问私有属性来模拟sessionManager + (authService as any).sessionManager = mockSessionManager; + + // 验证认证状态 + const result = await authService.isAuthenticated(); + expect(result).toBe(true); + expect(mockSessionManager.isAuthenticated).toHaveBeenCalledTimes(1); + }); + }); + + describe('getCurrentUser', () => { + it('应该返回当前用户信息', async () => { + const mockUser = { + id: '1', + username: 'testuser', + email: 'test@example.com', + avatar: '', + nickname: 'Test User', + bio: '', + createdAt: new Date().toISOString(), + updatedAt: new Date().toISOString() + }; + + // 模拟sessionManager.getUserInfo返回用户信息 + const mockSessionManager = { + getUserInfo: vi.fn().mockResolvedValue(mockUser) + }; + + // 通过访问私有属性来模拟sessionManager + (authService as any).sessionManager = mockSessionManager; + + // 获取当前用户 + const user = await authService.getCurrentUser(); + + // 验证用户信息 + expect(user).toEqual(mockUser); + expect(mockSessionManager.getUserInfo).toHaveBeenCalledTimes(1); + }); + + it('应该处理用户未认证的情况', async () => { + // 模拟sessionManager.getUserInfo抛出ApiError + const mockError = new ApiError(401, 'Session expired', {}); + const mockSessionManager = { + getUserInfo: vi.fn().mockRejectedValue(mockError) + }; + + // 通过访问私有属性来模拟sessionManager + (authService as any).sessionManager = mockSessionManager; + + // 获取当前用户并期望失败 + await expect(authService.getCurrentUser()).rejects.toThrowError( + expect.objectContaining({ + name: 'AuthError', + code: 'USER_NOT_FOUND' + }) + ); + + expect(mockSessionManager.getUserInfo).toHaveBeenCalledTimes(1); + }); + }); + + describe('clearCache', () => { + it('应该清除缓存', () => { + // 模拟sessionManager.clearCache + const mockSessionManager = { + clearCache: vi.fn() + }; + + // 通过访问私有属性来模拟sessionManager + (authService as any).sessionManager = mockSessionManager; + + // 清除缓存 + authService.clearCache(); + + // 验证clearCache被调用 + expect(mockSessionManager.clearCache).toHaveBeenCalledTimes(1); + }); + }); + + describe('事件监听', () => { + it('应该添加事件监听器', () => { + const mockListener = vi.fn(); + + // 添加事件监听器 + authService.on('login', mockListener); + + // 验证监听器已添加 + // 注意：由于我们使用的是单例authEventManager，这里我们只能验证方法被调用 + // 实际的事件触发测试在event-manager.test.ts中进行 + expect(typeof mockListener).toBe('function'); + }); + + it('应该移除事件监听器', () => { + const mockListener = vi.fn(); + + // 添加并移除事件监听器 + authService.on('login', mockListener); + authService.off('login', mockListener); + + // 验证监听器已移除 + // 注意：由于我们使用的是单例authEventManager，这里我们只能验证方法被调用 + // 实际的事件触发测试在event-manager.test.ts中进行 + expect(typeof mockListener).toBe('function'); + }); + }); + + describe('请求拦截器', () => { + it('应该添加请求拦截器', () => { + // 重置模拟函数的调用记录 + vi.clearAllMocks(); + + // 主动调用添加拦截器的方法 + apiClient.addRequestInterceptor(); + + // 验证拦截器是否被调用 + expect(apiClient.addRequestInterceptor).toHaveBeenCalled(); + }); + }); + + describe('响应拦截器', () => { + it('应该添加响应拦截器', () => { + // 重置模拟函数的调用记录 + vi.clearAllMocks(); + + // 主动调用添加拦截器的方法 + apiClient.addResponseInterceptor(); + + // 验证拦截器是否被调用 + expect(apiClient.addResponseInterceptor).toHaveBeenCalled(); + }); + }); +}); diff --git a/test/unit/auth/event-manager.test.ts b/test/unit/auth/event-manager.test.ts new file mode 100644 index 0000000..913611b --- /dev/null +++ b/test/unit/auth/event-manager.test.ts @@ -0,0 +1,174 @@ +/** + * AuthEventManager 单元测试 + */ + +import { describe, it, expect, beforeEach, vi } from 'vitest'; +import { AuthEventManager, authEventManager } from '@/auth/event-manager'; +import type { AuthEventListener } from '@/auth/event-manager'; + +describe('AuthEventManager', () => { + let eventManager: AuthEventManager; + let mockListener1: AuthEventListener; + let mockListener2: AuthEventListener; + + beforeEach(() => { + eventManager = new AuthEventManager(); + mockListener1 = vi.fn(); + mockListener2 = vi.fn(); + vi.clearAllMocks(); + }); + + describe('on', () => { + it('应该添加事件监听器', () => { + eventManager.on('login_success', mockListener1); + + // 触发事件 + eventManager.emit('login_success', { user: 'test' }); + + expect(mockListener1).toHaveBeenCalledWith({ user: 'test' }); + expect(mockListener1).toHaveBeenCalledTimes(1); + }); + + it('应该支持为同一事件添加多个监听器', () => { + eventManager.on('login_success', mockListener1); + eventManager.on('login_success', mockListener2); + + // 触发事件 + eventManager.emit('login_success', { user: 'test' }); + + expect(mockListener1).toHaveBeenCalledWith({ user: 'test' }); + expect(mockListener2).toHaveBeenCalledWith({ user: 'test' }); + }); + + it('应该支持为不同事件添加监听器', () => { + eventManager.on('login_success', mockListener1); + eventManager.on('logout', mockListener2); + + // 只触发登录成功事件 + eventManager.emit('login_success', { user: 'test' }); + + expect(mockListener1).toHaveBeenCalledWith({ user: 'test' }); + expect(mockListener1).toHaveBeenCalledTimes(1); + expect(mockListener2).not.toHaveBeenCalled(); + }); + }); + + describe('off', () => { + it('应该移除事件监听器', () => { + eventManager.on('login_success', mockListener1); + eventManager.on('login_success', mockListener2); + + // 移除第一个监听器 + eventManager.off('login_success', mockListener1); + + // 触发事件 + eventManager.emit('login_success', { user: 'test' }); + + expect(mockListener1).not.toHaveBeenCalled(); + expect(mockListener2).toHaveBeenCalledWith({ user: 'test' }); + expect(mockListener2).toHaveBeenCalledTimes(1); + }); + + it('应该只移除指定的监听器', () => { + eventManager.on('login_success', mockListener1); + eventManager.on('logout', mockListener1); + + // 只移除登录成功事件的监听器 + eventManager.off('login_success', mockListener1); + + // 触发两个事件 + eventManager.emit('login_success', { user: 'test' }); + eventManager.emit('logout', { user: 'test' }); + + expect(mockListener1).toHaveBeenCalledTimes(1); + expect(mockListener1).toHaveBeenCalledWith({ user: 'test' }); + }); + + it('应该处理移除不存在的监听器', () => { + // 尝试移除未添加的监听器 + eventManager.off('login_success', mockListener1); + + // 添加并触发事件 + eventManager.on('login_success', mockListener2); + eventManager.emit('login_success', { user: 'test' }); + + expect(mockListener1).not.toHaveBeenCalled(); + expect(mockListener2).toHaveBeenCalledWith({ user: 'test' }); + }); + }); + + describe('emit', () => { + it('应该触发事件并传递参数', () => { + eventManager.on('login_success', mockListener1); + + const args = [{ user: 'test' }, { token: 'abc123' }]; + eventManager.emit('login_success', ...args); + + expect(mockListener1).toHaveBeenCalledWith(...args); + }); + + it('应该触发所有监听器', () => { + eventManager.on('login_success', mockListener1); + eventManager.on('login_success', mockListener2); + + eventManager.emit('login_success', { user: 'test' }); + + expect(mockListener1).toHaveBeenCalledWith({ user: 'test' }); + expect(mockListener2).toHaveBeenCalledWith({ user: 'test' }); + }); + + it('应该处理没有监听器的事件', () => { + // 尝试触发没有监听器的事件 + expect(() => { + eventManager.emit('login_success', { user: 'test' }); + }).not.toThrow(); + }); + + it('应该处理监听器中的异常', () => { + const errorListener = vi.fn(() => { + throw new Error('Test error'); + }); + + eventManager.on('login_success', errorListener); + eventManager.on('login_success', mockListener2); + + // 即使一个监听器抛出异常，其他监听器也应该被调用 + expect(() => { + eventManager.emit('login_success', { user: 'test' }); + }).toThrow('Error in auth event listener for login_success'); + + expect(errorListener).toHaveBeenCalled(); + // 注意：由于第一个监听器抛出异常，第二个监听器可能不会被调用 + // 这取决于具体实现，这里我们只验证错误监听器被调用 + }); + }); + + describe('clear', () => { + it('应该清除所有监听器', () => { + // 添加多个事件监听器 + eventManager.on('login_success', mockListener1); + eventManager.on('logout', mockListener2); + + // 清除所有监听器 + eventManager.clear(); + + // 触发事件，验证监听器已被清除 + eventManager.emit('login_success', { user: 'test' }); + eventManager.emit('logout', { user: 'test' }); + + expect(mockListener1).not.toHaveBeenCalled(); + expect(mockListener2).not.toHaveBeenCalled(); + }); + }); +}); + +describe('authEventManager', () => { + it('应该是AuthEventManager的实例', () => { + expect(authEventManager).toBeInstanceOf(AuthEventManager); + }); + + it('应该是单例', () => { + const anotherInstance = authEventManager; + expect(anotherInstance).toBe(authEventManager); + }); +}); diff --git a/test/unit/utils/data.test.ts b/test/unit/utils/data.test.ts new file mode 100644 index 0000000..8f62d36 --- /dev/null +++ b/test/unit/utils/data.test.ts @@ -0,0 +1,482 @@ +import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'; +import { + throttle, + deepClone, + deepEqual, + pick, + omit, + merge, + toQueryString, + fromQueryString, + unique, + groupBy, + sortBy, + debounce +} from '@/utils/data'; + +describe('数据处理工具函数', () => { + describe('throttle', () => { + beforeEach(() => { + vi.useFakeTimers(); + }); + + afterEach(() => { + vi.useRealTimers(); + }); + + it('应该节流函数调用', () => { + const mockFn = vi.fn(); + const throttledFn = throttle(mockFn, 100); + + // 多次调用 + throttledFn(); + throttledFn(); + throttledFn(); + + // 在等待时间内，函数应该只被调用一次 + expect(mockFn).toHaveBeenCalledTimes(1); + + // 快进时间 + vi.advanceTimersByTime(100); + + // 再次调用 + throttledFn(); + throttledFn(); + + // 函数应该被调用第二次 + expect(mockFn).toHaveBeenCalledTimes(2); + }); + + it('应该支持leading选项', () => { + const mockFn = vi.fn(); + const throttledFn = throttle(mockFn, 100, { leading: false }); + + // 多次调用 + throttledFn(); + throttledFn(); + + // 由于leading为false，函数不应该被调用 + expect(mockFn).toHaveBeenCalledTimes(0); + + // 快进时间 + vi.advanceTimersByTime(100); + + // 函数应该被调用 + expect(mockFn).toHaveBeenCalledTimes(1); + }); + + it('应该支持trailing选项', () => { + const mockFn = vi.fn(); + const throttledFn = throttle(mockFn, 100, { trailing: false }); + + // 多次调用 + throttledFn(); + throttledFn(); + + // 快进时间 + vi.advanceTimersByTime(100); + + // 由于trailing为false，函数应该只被调用一次（第一次调用） + expect(mockFn).toHaveBeenCalledTimes(1); + }); + }); + + describe('debounce', () => { + beforeEach(() => { + vi.useFakeTimers(); + }); + + afterEach(() => { + vi.useRealTimers(); + }); + + it('应该防抖函数调用', () => { + const mockFn = vi.fn(); + const debouncedFn = debounce(mockFn, 100); + + // 多次调用 + debouncedFn(); + debouncedFn(); + debouncedFn(); + + // 在等待时间内，函数不应该被调用 + expect(mockFn).toHaveBeenCalledTimes(0); + + // 快进时间 + vi.advanceTimersByTime(100); + + // 函数应该被调用一次 + expect(mockFn).toHaveBeenCalledTimes(1); + }); + + it('应该支持immediate选项', () => { + const mockFn = vi.fn(); + const debouncedFn = debounce(mockFn, 100, true); + + // 第一次调用 + debouncedFn(); + + // 由于immediate为true，函数应该立即被调用 + expect(mockFn).toHaveBeenCalledTimes(1); + + // 再次调用（在等待时间内） + debouncedFn(); + + // 函数仍然应该只被调用一次（第二次调用被防抖了） + expect(mockFn).toHaveBeenCalledTimes(1); + + // 快进时间超过等待期 + vi.advanceTimersByTime(100); + + // 再次调用（等待期后） + debouncedFn(); + + // 函数应该被调用第二次（立即执行） + expect(mockFn).toHaveBeenCalledTimes(2); + }); + }); + + describe('deepClone', () => { + it('应该深拷贝基本类型', () => { + expect(deepClone(null)).toBe(null); + expect(deepClone(undefined)).toBe(undefined); + expect(deepClone(123)).toBe(123); + expect(deepClone('string')).toBe('string'); + expect(deepClone(true)).toBe(true); + }); + + it('应该深拷贝日期对象', () => { + const date = new Date('2023-05-15T10:30:45Z'); + const clonedDate = deepClone(date); + + expect(clonedDate).not.toBe(date); // 不是同一个对象 + expect(clonedDate.getTime()).toBe(date.getTime()); // 但时间相同 + }); + + it('应该深拷贝数组', () => { + const array = [1, 'string', { a: 1 }, [2, 3]]; + const clonedArray = deepClone(array); + + expect(clonedArray).not.toBe(array); // 不是同一个对象 + expect(clonedArray).toEqual(array); // 但内容相同 + expect(clonedArray[2]).not.toBe(array[2]); // 嵌套对象也被深拷贝 + expect(clonedArray[3]).not.toBe(array[3]); // 嵌套数组也被深拷贝 + }); + + it('应该深拷贝对象', () => { + const obj = { + a: 1, + b: 'string', + c: { + d: 2, + e: [3, 4] + }, + f: new Date('2023-05-15T10:30:45Z') + }; + const clonedObj = deepClone(obj); + + expect(clonedObj).not.toBe(obj); // 不是同一个对象 + expect(clonedObj).toEqual(obj); // 但内容相同 + expect(clonedObj.c).not.toBe(obj.c); // 嵌套对象也被深拷贝 + expect(clonedObj.c.e).not.toBe(obj.c.e); // 嵌套数组也被深拷贝 + expect(clonedObj.f).not.toBe(obj.f); // 日期对象也被深拷贝 + }); + }); + + describe('deepEqual', () => { + it('应该比较基本类型', () => { + expect(deepEqual(1, 1)).toBe(true); + expect(deepEqual('string', 'string')).toBe(true); + expect(deepEqual(true, true)).toBe(true); + expect(deepEqual(null, null)).toBe(true); + expect(deepEqual(undefined, undefined)).toBe(true); + + expect(deepEqual(1, 2)).toBe(false); + expect(deepEqual('string', 'other')).toBe(false); + expect(deepEqual(true, false)).toBe(false); + expect(deepEqual(null, undefined)).toBe(false); + }); + + it('应该比较数组', () => { + expect(deepEqual([1, 2, 3], [1, 2, 3])).toBe(true); + expect(deepEqual([1, 2, 3], [1, 2, 4])).toBe(false); + expect(deepEqual([1, 2, 3], [1, 2])).toBe(false); + expect(deepEqual([1, 2, 3], [3, 2, 1])).toBe(false); + }); + + it('应该比较对象', () => { + expect(deepEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true); + expect(deepEqual({ a: 1, b: 2 }, { a: 1, b: 3 })).toBe(false); + expect(deepEqual({ a: 1, b: 2 }, { a: 1 })).toBe(false); + expect(deepEqual({ a: 1, b: 2 }, { b: 2, a: 1 })).toBe(true); // 顺序不重要 + }); + + it('应该深度比较嵌套对象', () => { + const obj1 = { a: 1, b: { c: 2, d: [3, 4] } }; + const obj2 = { a: 1, b: { c: 2, d: [3, 4] } }; + const obj3 = { a: 1, b: { c: 2, d: [3, 5] } }; + + expect(deepEqual(obj1, obj2)).toBe(true); + expect(deepEqual(obj1, obj3)).toBe(false); + }); + }); + + describe('pick', () => { + it('应该从对象中选取指定的属性', () => { + const obj = { a: 1, b: 2, c: 3, d: 4 }; + const result = pick(obj, ['a', 'c']); + + expect(result).toEqual({ a: 1, c: 3 }); + expect(result).not.toBe(obj); // 返回新对象 + }); + + it('应该处理不存在的属性', () => { + const obj = { a: 1, b: 2 }; + const result = pick(obj, ['a', 'c']); + + expect(result).toEqual({ a: 1 }); + }); + + it('应该处理空键数组', () => { + const obj = { a: 1, b: 2 }; + const result = pick(obj, []); + + expect(result).toEqual({}); + }); + }); + + describe('omit', () => { + it('应该从对象中排除指定的属性', () => { + const obj = { a: 1, b: 2, c: 3, d: 4 }; + const result = omit(obj, ['a', 'c']); + + expect(result).toEqual({ b: 2, d: 4 }); + expect(result).not.toBe(obj); // 返回新对象 + }); + + it('应该处理不存在的属性', () => { + const obj = { a: 1, b: 2 }; + const result = omit(obj, ['a', 'c']); + + expect(result).toEqual({ b: 2 }); + }); + + it('应该处理空键数组', () => { + const obj = { a: 1, b: 2 }; + const result = omit(obj, []); + + expect(result).toEqual(obj); + expect(result).not.toBe(obj); // 仍然返回新对象 + }); + }); + + describe('merge', () => { + it('应该合并多个对象', () => { + const obj1 = { a: 1, b: 2 }; + const obj2 = { b: 3, c: 4 }; + const obj3 = { d: 5 }; + + const result = merge(obj1, obj2, obj3); + + expect(result).toEqual({ a: 1, b: 3, c: 4, d: 5 }); + }); + + it('应该处理null或undefined对象', () => { + const obj1 = { a: 1 }; + const obj2 = null; + const obj3 = undefined; + const obj4 = { b: 2 }; + + const result = merge(obj1, obj2, obj3, obj4); + + expect(result).toEqual({ a: 1, b: 2 }); + }); + + it('应该处理非对象值', () => { + const obj1 = { a: 1 }; + const obj2 = 'string'; + const obj3 = 123; + + const result = merge(obj1, obj2, obj3); + + expect(result).toEqual({ a: 1 }); + }); + }); + + describe('toQueryString', () => { + it('应该将对象转换为查询字符串', () => { + const obj = { a: '1', b: 'test', c: 'value' }; + const result = toQueryString(obj); + + expect(result).toBe('a=1&b=test&c=value'); + }); + + it('应该处理null和undefined值', () => { + const obj = { a: '1', b: null, c: undefined, d: '4' }; + const result = toQueryString(obj); + + expect(result).toBe('a=1&d=4'); + }); + + it('应该处理数字和布尔值', () => { + const obj = { a: 1, b: true, c: false }; + const result = toQueryString(obj); + + expect(result).toBe('a=1&b=true&c=false'); + }); + + it('应该处理空对象', () => { + const obj = {}; + const result = toQueryString(obj); + + expect(result).toBe(''); + }); + }); + + describe('fromQueryString', () => { + it('应该将查询字符串转换为对象', () => { + const queryString = 'a=1&b=test&c=value'; + const result = fromQueryString(queryString); + + expect(result).toEqual({ a: '1', b: 'test', c: 'value' }); + }); + + it('应该处理空查询字符串', () => { + const queryString = ''; + const result = fromQueryString(queryString); + + expect(result).toEqual({}); + }); + + it('应该处理特殊字符', () => { + const queryString = 'a=hello%20world&b=test%20%26%20value'; + const result = fromQueryString(queryString); + + expect(result).toEqual({ a: 'hello world', b: 'test & value' }); + }); + }); + + describe('unique', () => { + it('应该对基本类型数组去重', () => { + const array = [1, 2, 3, 2, 4, 1, 5]; + const result = unique(array); + + expect(result).toEqual([1, 2, 3, 4, 5]); + }); + + it('应该使用键函数对复杂对象数组去重', () => { + const array = [ + { id: 1, name: 'Alice' }, + { id: 2, name: 'Bob' }, + { id: 1, name: 'Alice Smith' }, + { id: 3, name: 'Charlie' }, + { id: 2, name: 'Bob Johnson' } + ]; + + const result = unique(array, (item: { id: number }) => item.id); + + expect(result).toEqual([ + { id: 1, name: 'Alice' }, + { id: 2, name: 'Bob' }, + { id: 3, name: 'Charlie' } + ]); + }); + + it('应该处理空数组', () => { + const array: number[] = []; + const result = unique(array); + + expect(result).toEqual([]); + }); + }); + + describe('groupBy', () => { + it('应该按指定键对数组分组', () => { + const array = [ + { category: 'fruit', name: 'Apple' }, + { category: 'vegetable', name: 'Carrot' }, + { category: 'fruit', name: 'Banana' }, + { category: 'fruit', name: 'Orange' }, + { category: 'vegetable', name: 'Broccoli' } + ]; + + const result = groupBy(array, (item: { category: string }) => item.category); + + expect(result).toEqual({ + fruit: [ + { category: 'fruit', name: 'Apple' }, + { category: 'fruit', name: 'Banana' }, + { category: 'fruit', name: 'Orange' } + ], + vegetable: [ + { category: 'vegetable', name: 'Carrot' }, + { category: 'vegetable', name: 'Broccoli' } + ] + }); + }); + + it('应该处理空数组', () => { + const array: any[] = []; + const result = groupBy(array, (item: { category: string }) => item.category); + + expect(result).toEqual({}); + }); + + it('应该处理数字键', () => { + const array = [ + { score: 90, name: 'Alice' }, + { score: 80, name: 'Bob' }, + { score: 90, name: 'Charlie' }, + { score: 70, name: 'David' } + ]; + + const result = groupBy(array, (item: { score: number }) => item.score); + + expect(result).toEqual({ + 90: [ + { score: 90, name: 'Alice' }, + { score: 90, name: 'Charlie' } + ], + 80: [ + { score: 80, name: 'Bob' } + ], + 70: [ + { score: 70, name: 'David' } + ] + }); + }); + }); + + describe('sortBy', () => { + it('应该使用默认比较函数对数组排序', () => { + const array = [3, 1, 4, 1, 5, 9, 2, 6]; + const result = sortBy(array); + + expect(result).toEqual([1, 1, 2, 3, 4, 5, 6, 9]); + expect(result).not.toBe(array); // 返回新数组 + }); + + it('应该使用自定义比较函数对数组排序', () => { + const array = [ + { name: 'Alice', age: 30 }, + { name: 'Bob', age: 25 }, + { name: 'Charlie', age: 35 } + ]; + + const result = sortBy(array, (a: { age: number }, b: { age: number }) => a.age - b.age); + + expect(result).toEqual([ + { name: 'Bob', age: 25 }, + { name: 'Alice', age: 30 }, + { name: 'Charlie', age: 35 } + ]); + }); + + it('应该处理空数组', () => { + const array: any[] = []; + const result = sortBy(array); + + expect(result).toEqual([]); + }); + }); +}); diff --git a/test/unit/utils/date.test.ts b/test/unit/utils/date.test.ts new file mode 100644 index 0000000..7b17dd3 --- /dev/null +++ b/test/unit/utils/date.test.ts @@ -0,0 +1,157 @@ +import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'; +import { dateUtils } from '@/utils/date'; + +describe('dateUtils', () => { + // 模拟当前时间 + const mockCurrentDate = new Date('2023-05-15T12:00:00Z'); + + beforeEach(() => { + // 使用 vi.useFakeTimers 模拟当前时间 + vi.useFakeTimers(); + vi.setSystemTime(mockCurrentDate); + }); + + afterEach(() => { + // 恢复真实时间 + vi.useRealTimers(); + }); + + describe('formatDate', () => { + it('应该格式化日期对象', () => { + const date = new Date('2023-05-15T10:30:45Z'); + expect(dateUtils.formatDate(date, 'YYYY-MM-DD')).toBe('2023-05-15'); + expect(dateUtils.formatDate(date, 'YYYY-MM-DD HH:mm:ss')).toBe('2023-05-15 10:30:45'); + }); + + it('应该格式化日期字符串', () => { + const dateString = '2023-05-15T10:30:45Z'; + expect(dateUtils.formatDate(dateString, 'YYYY-MM-DD')).toBe('2023-05-15'); + expect(dateUtils.formatDate(dateString, 'YYYY-MM-DD HH:mm')).toBe('2023-05-15 10:30'); + }); + + it('应该使用默认格式', () => { + const date = new Date('2023-05-15T10:30:45Z'); + expect(dateUtils.formatDate(date)).toBe('2023-05-15'); + }); + + it('应该处理无效日期', () => { + const invalidDate = new Date('invalid'); + expect(dateUtils.formatDate(invalidDate)).toBe(''); + expect(dateUtils.formatDate('invalid date')).toBe(''); + }); + + it('应该正确格式化单个数字的月份和日期', () => { + const date = new Date('2023-01-02T03:04:05Z'); + expect(dateUtils.formatDate(date, 'YYYY-MM-DD HH:mm:ss')).toBe('2023-01-02 03:04:05'); + }); + }); + + describe('getRelativeTime', () => { + it('应该显示"刚刚"对于几秒前的时间', () => { + const date = new Date(mockCurrentDate.getTime() - 30 * 1000); // 30秒前 + expect(dateUtils.getRelativeTime(date)).toBe('刚刚'); + }); + + it('应该显示"X分钟前"对于几分钟前的时间', () => { + const date = new Date(mockCurrentDate.getTime() - 5 * 60 * 1000); // 5分钟前 + expect(dateUtils.getRelativeTime(date)).toBe('5分钟前'); + }); + + it('应该显示"X小时前"对于几小时前的时间', () => { + const date = new Date(mockCurrentDate.getTime() - 3 * 60 * 60 * 1000); // 3小时前 + expect(dateUtils.getRelativeTime(date)).toBe('3小时前'); + }); + + it('应该显示"X天前"对于几天前的时间', () => { + const date = new Date(mockCurrentDate.getTime() - 5 * 24 * 60 * 60 * 1000); // 5天前 + expect(dateUtils.getRelativeTime(date)).toBe('5天前'); + }); + + it('应该显示"X周前"对于几周前的时间', () => { + const date = new Date(mockCurrentDate.getTime() - 2 * 7 * 24 * 60 * 60 * 1000); // 2周前 + expect(dateUtils.getRelativeTime(date)).toBe('2周前'); + }); + + it('应该显示"X个月前"对于几个月前的时间', () => { + const date = new Date(mockCurrentDate.getTime() - 3 * 30 * 24 * 60 * 60 * 1000); // 3个月前 + expect(dateUtils.getRelativeTime(date)).toBe('3个月前'); + }); + + it('应该显示"X年前"对于几年前的时间', () => { + const date = new Date(mockCurrentDate.getTime() - 2 * 365 * 24 * 60 * 60 * 1000); // 2年前 + expect(dateUtils.getRelativeTime(date)).toBe('2年前'); + }); + + it('应该返回绝对时间对于未来的时间', () => { + const futureDate = new Date(mockCurrentDate.getTime() + 24 * 60 * 60 * 1000); // 1天后 + expect(dateUtils.getRelativeTime(futureDate)).toBe('2023-05-16 12:00'); + }); + + it('应该处理字符串日期', () => { + const dateString = '2023-05-14T12:00:00Z'; // 1天前 + expect(dateUtils.getRelativeTime(dateString)).toBe('1天前'); + }); + }); + + describe('isToday', () => { + it('应该识别今天的日期', () => { + const today = new Date(mockCurrentDate); + expect(dateUtils.isToday(today)).toBe(true); + }); + + it('应该识别不是今天的日期', () => { + const yesterday = new Date(mockCurrentDate.getTime() - 24 * 60 * 60 * 1000); + const tomorrow = new Date(mockCurrentDate.getTime() + 24 * 60 * 60 * 1000); + + expect(dateUtils.isToday(yesterday)).toBe(false); + expect(dateUtils.isToday(tomorrow)).toBe(false); + }); + + it('应该处理字符串日期', () => { + const todayString = mockCurrentDate.toISOString(); + expect(dateUtils.isToday(todayString)).toBe(true); + }); + + it('应该处理不同时间但同一天的日期', () => { + const morning = new Date(mockCurrentDate); + morning.setHours(0, 0, 0, 0); + + const evening = new Date(mockCurrentDate); + evening.setHours(23, 59, 59, 999); + + expect(dateUtils.isToday(morning)).toBe(true); + expect(dateUtils.isToday(evening)).toBe(true); + }); + }); + + describe('isYesterday', () => { + it('应该识别昨天的日期', () => { + const yesterday = new Date(mockCurrentDate.getTime() - 24 * 60 * 60 * 1000); + expect(dateUtils.isYesterday(yesterday)).toBe(true); + }); + + it('应该识别不是昨天的日期', () => { + const today = new Date(mockCurrentDate); + const twoDaysAgo = new Date(mockCurrentDate.getTime() - 2 * 24 * 60 * 60 * 1000); + + expect(dateUtils.isYesterday(today)).toBe(false); + expect(dateUtils.isYesterday(twoDaysAgo)).toBe(false); + }); + + it('应该处理字符串日期', () => { + const yesterdayString = new Date(mockCurrentDate.getTime() - 24 * 60 * 60 * 1000).toISOString(); + expect(dateUtils.isYesterday(yesterdayString)).toBe(true); + }); + + it('应该处理不同时间但昨天的日期', () => { + const yesterdayMorning = new Date(mockCurrentDate.getTime() - 24 * 60 * 60 * 1000); + yesterdayMorning.setHours(0, 0, 0, 0); + + const yesterdayEvening = new Date(mockCurrentDate.getTime() - 24 * 60 * 60 * 1000); + yesterdayEvening.setHours(23, 59, 59, 999); + + expect(dateUtils.isYesterday(yesterdayMorning)).toBe(true); + expect(dateUtils.isYesterday(yesterdayEvening)).toBe(true); + }); + }); +}); diff --git a/test/unit/utils/string.test.ts b/test/unit/utils/string.test.ts new file mode 100644 index 0000000..63f2e94 --- /dev/null +++ b/test/unit/utils/string.test.ts @@ -0,0 +1,183 @@ +import { describe, it, expect } from 'vitest'; +import { stringUtils } from '@/utils/string'; + +describe('stringUtils', () => { + describe('truncate', () => { + it('应该截断长字符串并添加省略号', () => { + const longString = 'This is a very long string that should be truncated'; + const result = stringUtils.truncate(longString, 20); + expect(result).toBe('This is a very lo...'); + }); + + it('应该使用自定义后缀', () => { + const longString = 'This is a very long string that should be truncated'; + const result = stringUtils.truncate(longString, 21, ' [more]'); + expect(result).toBe('This is a very [more]'); + }); + + it('不应该截断短字符串', () => { + const shortString = 'Short string'; + const result = stringUtils.truncate(shortString, 20); + expect(result).toBe(shortString); + }); + + it('应该处理长度等于最大长度的字符串', () => { + const exactString = 'Exact length'; + const result = stringUtils.truncate(exactString, 12); + expect(result).toBe(exactString); + }); + }); + + describe('capitalize', () => { + it('应该将字符串首字母大写', () => { + expect(stringUtils.capitalize('hello')).toBe('Hello'); + expect(stringUtils.capitalize('world')).toBe('World'); + }); + + it('应该处理空字符串', () => { + expect(stringUtils.capitalize('')).toBe(''); + }); + + it('应该保持已大写的首字母', () => { + expect(stringUtils.capitalize('Hello')).toBe('Hello'); + }); + + it('应该只改变首字母，保持其余部分不变', () => { + expect(stringUtils.capitalize('hELLO')).toBe('HELLO'); + }); + }); + + describe('toCamelCase', () => { + it('应该将短横线分隔的字符串转换为驼峰命名', () => { + expect(stringUtils.toCamelCase('hello-world')).toBe('helloWorld'); + expect(stringUtils.toCamelCase('my-variable-name')).toBe('myVariableName'); + }); + + it('应该将下划线分隔的字符串转换为驼峰命名', () => { + expect(stringUtils.toCamelCase('hello_world')).toBe('helloWorld'); + expect(stringUtils.toCamelCase('my_variable_name')).toBe('myVariableName'); + }); + + it('应该将空格分隔的字符串转换为驼峰命名', () => { + expect(stringUtils.toCamelCase('hello world')).toBe('helloWorld'); + expect(stringUtils.toCamelCase('my variable name')).toBe('myVariableName'); + }); + + it('应该处理混合分隔符', () => { + expect(stringUtils.toCamelCase('hello-world_test variable')).toBe('helloWorldTestVariable'); + }); + + it('应该处理空字符串', () => { + expect(stringUtils.toCamelCase('')).toBe(''); + }); + + it('应该处理已经驼峰命名的字符串', () => { + expect(stringUtils.toCamelCase('helloWorld')).toBe('helloWorld'); + }); + + it('应该将首字母小写', () => { + expect(stringUtils.toCamelCase('Hello-World')).toBe('helloWorld'); + expect(stringUtils.toCamelCase('HELLO_WORLD')).toBe('helloWorld'); + }); + }); + + describe('toKebabCase', () => { + it('应该将驼峰命名转换为短横线分隔', () => { + expect(stringUtils.toKebabCase('helloWorld')).toBe('hello-world'); + expect(stringUtils.toKebabCase('myVariableName')).toBe('my-variable-name'); + }); + + it('应该处理已短横线分隔的字符串', () => { + expect(stringUtils.toKebabCase('hello-world')).toBe('hello-world'); + }); + + it('应该处理下划线分隔的字符串', () => { + expect(stringUtils.toKebabCase('hello_world')).toBe('hello-world'); + }); + + it('应该处理空字符串', () => { + expect(stringUtils.toKebabCase('')).toBe(''); + }); + }); + + describe('toSnakeCase', () => { + it('应该将驼峰命名转换为下划线分隔', () => { + expect(stringUtils.toSnakeCase('helloWorld')).toBe('hello_world'); + expect(stringUtils.toSnakeCase('myVariableName')).toBe('my_variable_name'); + }); + + it('应该处理已下划线分隔的字符串', () => { + expect(stringUtils.toSnakeCase('hello_world')).toBe('hello_world'); + }); + + it('应该处理短横线分隔的字符串', () => { + expect(stringUtils.toSnakeCase('hello-world')).toBe('hello_world'); + }); + + it('应该处理空字符串', () => { + expect(stringUtils.toSnakeCase('')).toBe(''); + }); + }); + + describe('escapeHtml', () => { + it('应该转义HTML特殊字符', () => { + expect(stringUtils.escapeHtml('
hello & world
')).toBe('<div>hello & world</div>'); + expect(stringUtils.escapeHtml('a "quote" and \'apostrophe\'')).toBe('a "quote" and 'apostrophe''); + }); + + it('应该处理不包含特殊字符的字符串', () => { + expect(stringUtils.escapeHtml('plain text')).toBe('plain text'); + }); + + it('应该处理空字符串', () => { + expect(stringUtils.escapeHtml('')).toBe(''); + }); + + it('应该只转义已知的特殊字符', () => { + expect(stringUtils.escapeHtml('hello @ world #test')).toBe('hello @ world #test'); + }); + }); + + describe('randomString', () => { + it('应该生成指定长度的随机字符串', () => { + const length = 10; + const result = stringUtils.randomString(length); + expect(result).toHaveLength(length); + }); + + it('应该生成不同的随机字符串', () => { + const result1 = stringUtils.randomString(10); + const result2 = stringUtils.randomString(10); + expect(result1).not.toBe(result2); + }); + + it('应该使用默认长度', () => { + const result = stringUtils.randomString(); + expect(result).toHaveLength(10); + }); + + it('应该只包含字母和数字', () => { + const result = stringUtils.randomString(100); + const regex = /^[A-Za-z0-9]+$/; + expect(regex.test(result)).toBe(true); + }); + }); + + describe('isEmpty', () => { + it('应该识别空字符串', () => { + expect(stringUtils.isEmpty('')).toBe(true); + expect(stringUtils.isEmpty(' ')).toBe(true); + expect(stringUtils.isEmpty('\t\n')).toBe(true); + }); + + it('应该识别非空字符串', () => { + expect(stringUtils.isEmpty('hello')).toBe(false); + expect(stringUtils.isEmpty(' hello ')).toBe(false); + }); + + it('应该处理null和undefined', () => { + expect(stringUtils.isEmpty(null)).toBe(true); + expect(stringUtils.isEmpty(undefined)).toBe(true); + }); + }); +}); diff --git a/test/unit/utils/validation.test.ts b/test/unit/utils/validation.test.ts new file mode 100644 index 0000000..621c823 --- /dev/null +++ b/test/unit/utils/validation.test.ts @@ -0,0 +1,224 @@ +import { describe, it, expect } from 'vitest'; +import { validationUtils } from '@/utils/validation'; + +describe('validationUtils', () => { + describe('isEmail', () => { + it('应该验证有效的邮箱地址', () => { + expect(validationUtils.isEmail('test@example.com')).toBe(true); + expect(validationUtils.isEmail('user.name@domain.co.uk')).toBe(true); + expect(validationUtils.isEmail('user+tag@example.org')).toBe(true); + }); + + it('应该拒绝无效的邮箱地址', () => { + expect(validationUtils.isEmail('')).toBe(false); + expect(validationUtils.isEmail('test')).toBe(false); + expect(validationUtils.isEmail('test@')).toBe(false); + expect(validationUtils.isEmail('@example.com')).toBe(false); + expect(validationUtils.isEmail('test@.com')).toBe(false); + expect(validationUtils.isEmail('test@example')).toBe(false); + expect(validationUtils.isEmail('test example.com')).toBe(false); + }); + }); + + describe('isPhoneNumber', () => { + it('应该验证有效的手机号（中国大陆）', () => { + expect(validationUtils.isPhoneNumber('13812345678')).toBe(true); + expect(validationUtils.isPhoneNumber('15987654321')).toBe(true); + expect(validationUtils.isPhoneNumber('18612345678')).toBe(true); + }); + + it('应该拒绝无效的手机号', () => { + expect(validationUtils.isPhoneNumber('')).toBe(false); + expect(validationUtils.isPhoneNumber('12345678901')).toBe(false); + expect(validationUtils.isPhoneNumber('12812345678')).toBe(false); + expect(validationUtils.isPhoneNumber('1381234567')).toBe(false); + expect(validationUtils.isPhoneNumber('138123456789')).toBe(false); + expect(validationUtils.isPhoneNumber('abcdefghijk')).toBe(false); + }); + }); + + describe('isIdCard', () => { + it('应该验证有效的身份证号（中国大陆）', () => { + expect(validationUtils.isIdCard('123456789012345')).toBe(true); // 15位 + expect(validationUtils.isIdCard('123456789012345678')).toBe(true); // 18位数字 + expect(validationUtils.isIdCard('12345678901234567X')).toBe(true); // 18位以X结尾 + expect(validationUtils.isIdCard('12345678901234567x')).toBe(true); // 18位以x结尾 + }); + + it('应该拒绝无效的身份证号', () => { + expect(validationUtils.isIdCard('')).toBe(false); + expect(validationUtils.isIdCard('12345678901234')).toBe(false); // 14位 + expect(validationUtils.isIdCard('1234567890123456')).toBe(false); // 16位 + expect(validationUtils.isIdCard('1234567890123456789')).toBe(false); // 19位 + expect(validationUtils.isIdCard('12345678901234567Y')).toBe(false); // 18位以Y结尾 + }); + }); + + describe('isStrongPassword', () => { + it('应该验证强密码', () => { + expect(validationUtils.isStrongPassword('Password123!')).toBe(true); + expect(validationUtils.isStrongPassword('StrongPass@2023')).toBe(true); + expect(validationUtils.isStrongPassword('Pass123!')).toBe(true); + }); + + it('应该拒绝弱密码', () => { + expect(validationUtils.isStrongPassword('')).toBe(false); + expect(validationUtils.isStrongPassword('password')).toBe(false); // 没有大写字母、数字和特殊字符 + expect(validationUtils.isStrongPassword('PASSWORD')).toBe(false); // 没有小写字母、数字和特殊字符 + expect(validationUtils.isStrongPassword('12345678')).toBe(false); // 没有字母和特殊字符 + expect(validationUtils.isStrongPassword('Password')).toBe(false); // 没有数字和特殊字符 + expect(validationUtils.isStrongPassword('Password123')).toBe(false); // 没有特殊字符 + }); + }); + + describe('isEmpty', () => { + it('应该识别空值', () => { + expect(validationUtils.isEmpty(null)).toBe(true); + expect(validationUtils.isEmpty(undefined)).toBe(true); + expect(validationUtils.isEmpty('')).toBe(true); + expect(validationUtils.isEmpty(' ')).toBe(true); + expect(validationUtils.isEmpty([])).toBe(true); + expect(validationUtils.isEmpty({})).toBe(true); + }); + + it('应该识别非空值', () => { + expect(validationUtils.isEmpty('text')).toBe(false); + expect(validationUtils.isEmpty(' text ')).toBe(false); + expect(validationUtils.isEmpty([1, 2, 3])).toBe(false); + expect(validationUtils.isEmpty({ key: 'value' })).toBe(false); + expect(validationUtils.isEmpty(0)).toBe(false); + expect(validationUtils.isEmpty(false)).toBe(false); + }); + }); + + describe('isInRange', () => { + it('应该验证范围内的数字', () => { + expect(validationUtils.isInRange(5, 1, 10)).toBe(true); + expect(validationUtils.isInRange(1, 1, 10)).toBe(true); + expect(validationUtils.isInRange(10, 1, 10)).toBe(true); + }); + + it('应该拒绝超出范围的数字', () => { + expect(validationUtils.isInRange(0, 1, 10)).toBe(false); + expect(validationUtils.isInRange(11, 1, 10)).toBe(false); + }); + }); + + describe('isLengthValid', () => { + it('应该验证有效长度', () => { + expect(validationUtils.isLengthValid('hello', 3, 10)).toBe(true); + expect(validationUtils.isLengthValid('hello', 5)).toBe(true); + expect(validationUtils.isLengthValid('hello', 1, 5)).toBe(true); + }); + + it('应该拒绝无效长度', () => { + expect(validationUtils.isLengthValid('hello', 6, 10)).toBe(false); // 太短 + expect(validationUtils.isLengthValid('hello', 1, 4)).toBe(false); // 太长 + expect(validationUtils.isLengthValid('', 1, 10)).toBe(false); // 太短 + }); + + it('应该处理只有最小长度的情况', () => { + expect(validationUtils.isLengthValid('hello', 5)).toBe(true); + expect(validationUtils.isLengthValid('hello', 6)).toBe(false); + }); + }); + + describe('isNumber', () => { + it('应该验证数字', () => { + expect(validationUtils.isNumber(0)).toBe(true); + expect(validationUtils.isNumber(123)).toBe(true); + expect(validationUtils.isNumber(-456)).toBe(true); + expect(validationUtils.isNumber(3.14)).toBe(true); + }); + + it('应该拒绝非数字', () => { + expect(validationUtils.isNumber('123')).toBe(false); + expect(validationUtils.isNumber(NaN)).toBe(false); + expect(validationUtils.isNumber(Infinity)).toBe(true); // Infinity被认为是数字 + expect(validationUtils.isNumber(null)).toBe(false); + expect(validationUtils.isNumber(undefined)).toBe(false); + }); + }); + + describe('isInteger', () => { + it('应该验证整数', () => { + expect(validationUtils.isInteger(0)).toBe(true); + expect(validationUtils.isInteger(123)).toBe(true); + expect(validationUtils.isInteger(-456)).toBe(true); + }); + + it('应该拒绝非整数', () => { + expect(validationUtils.isInteger(3.14)).toBe(false); + expect(validationUtils.isInteger('123')).toBe(false); + expect(validationUtils.isInteger(NaN)).toBe(false); + expect(validationUtils.isInteger(null)).toBe(false); + }); + }); + + describe('isPositive', () => { + it('应该验证正数', () => { + expect(validationUtils.isPositive(1)).toBe(true); + expect(validationUtils.isPositive(123.456)).toBe(true); + }); + + it('应该拒绝非正数', () => { + expect(validationUtils.isPositive(0)).toBe(false); + expect(validationUtils.isPositive(-1)).toBe(false); + expect(validationUtils.isPositive(-123.456)).toBe(false); + }); + }); + + describe('isNegative', () => { + it('应该验证负数', () => { + expect(validationUtils.isNegative(-1)).toBe(true); + expect(validationUtils.isNegative(-123.456)).toBe(true); + }); + + it('应该拒绝非负数', () => { + expect(validationUtils.isNegative(0)).toBe(false); + expect(validationUtils.isNegative(1)).toBe(false); + expect(validationUtils.isNegative(123.456)).toBe(false); + }); + }); + + describe('isEven', () => { + it('应该验证偶数', () => { + expect(validationUtils.isEven(0)).toBe(true); + expect(validationUtils.isEven(2)).toBe(true); + expect(validationUtils.isEven(-4)).toBe(true); + }); + + it('应该拒绝奇数', () => { + expect(validationUtils.isEven(1)).toBe(false); + expect(validationUtils.isEven(3)).toBe(false); + expect(validationUtils.isEven(-5)).toBe(false); + }); + }); + + describe('isOdd', () => { + it('应该验证奇数', () => { + expect(validationUtils.isOdd(1)).toBe(true); + expect(validationUtils.isOdd(3)).toBe(true); + expect(validationUtils.isOdd(-5)).toBe(true); + }); + + it('应该拒绝偶数', () => { + expect(validationUtils.isOdd(0)).toBe(false); + expect(validationUtils.isOdd(2)).toBe(false); + expect(validationUtils.isOdd(-4)).toBe(false); + }); + }); + + describe('isLeapYear', () => { + it('应该验证闰年', () => { + expect(validationUtils.isLeapYear(2000)).toBe(true); // 能被400整除 + expect(validationUtils.isLeapYear(2020)).toBe(true); // 能被4整除但不能被100整除 + }); + + it('应该拒绝非闰年', () => { + expect(validationUtils.isLeapYear(1900)).toBe(false); // 能被100整除但不能被400整除 + expect(validationUtils.isLeapYear(2023)).toBe(false); // 不能被4整除 + }); + }); + +}); diff --git a/test/utils/test-helpers.ts b/test/utils/test-helpers.ts new file mode 100644 index 0000000..2aa0bc6 --- /dev/null +++ b/test/utils/test-helpers.ts @@ -0,0 +1,159 @@ +/** + * 测试工具函数 + * 提供测试中常用的辅助函数 + */ + +import { vi } from 'vitest'; + +// 等待指定时间(和await一起用) +export function sleep(ms: number): Promise { + return new Promise(resolve => setTimeout(resolve, ms)); +} + +// 等待下一个事件循环(和await一起用) +export function nextTick(): Promise { + return new Promise(resolve => setTimeout(resolve, 0)); +} + +// 创建一个可控制的Promise(将promise的控制权提取到外部) +export function createControlledPromise() { + // 用闭包把内部函数暴露到外部 + let resolve: (value: T) => void; + let reject: (reason?: any) => void; + const promise = new Promise((res, rej) => { + resolve = res; + reject = rej; + }); + + return { + promise, + resolve: resolve!, + reject: reject! + }; +} + +// 模拟localStorage(闭包) +export function createMockLocalStorage() { + let store: Record = {}; + + return { + getItem: vi.fn((key: string) => store[key] || null), + setItem: vi.fn((key: string, value: string) => { + store[key] = value; + }), + removeItem: vi.fn((key: string) => { + delete store[key]; + }), + clear: vi.fn(() => { + store = {}; + }), + get length() { + return Object.keys(store).length; + }, + key: vi.fn((index: number) => { + const keys = Object.keys(store); + return keys[index] || null; + }) + }; +} + +// 模拟sessionStorage +export function createMockSessionStorage() { + return createMockLocalStorage(); +} + +// 创建一个可读写的流 +// 创建一个可读写的事件流 +export function createMockStream() { + const listeners: Record = {}; + + // 先创建对象引用 + const stream = { + on: vi.fn((event: string, callback: Function) => { + if (!listeners[event]) { + listeners[event] = []; + } + listeners[event].push(callback); + return stream; // 使用对象引用而不是 this + }), + + emit: vi.fn((event: string, ...args: any[]) => { + if (listeners[event]) { + listeners[event].forEach(callback => callback(...args)); + } + return stream; // 使用对象引用 + }), + + once: vi.fn((event: string, callback: Function) => { + const onceWrapper = (...args: any[]) => { + callback(...args); + // 移除监听器 + if (listeners[event]) { + listeners[event] = listeners[event].filter(cb => cb !== onceWrapper); + } + }; + return stream.on(event, onceWrapper); // 使用对象引用 + }), + + removeListener: vi.fn((event: string, callback: Function) => { + if (listeners[event]) { + listeners[event] = listeners[event].filter(cb => cb !== callback); + } + return stream; // 使用对象引用 + }), + + removeAllListeners: vi.fn((event?: string) => { + if (event) { + delete listeners[event]; + } else { + Object.keys(listeners).forEach(key => { + delete listeners[key]; + }); + } + return stream; // 使用对象引用 + }) + }; + + return stream; +} + +// 模拟IntersectionObserver +export function createMockIntersectionObserver() { + const callbacks: Function[] = []; + + return { + observe: vi.fn(), + unobserve: vi.fn(), + disconnect: vi.fn(), + root: null, + rootMargin: '', + thresholds: [], + constructor: vi.fn((callback: Function) => { + callbacks.push(callback); + return { + observe: vi.fn(), + unobserve: vi.fn(), + disconnect: vi.fn() + }; + }) + }; +} + +// 模拟ResizeObserver +export function createMockResizeObserver() { + const callbacks: Function[] = []; + + return { + observe: vi.fn(), + unobserve: vi.fn(), + disconnect: vi.fn(), + constructor: vi.fn((callback: Function) => { + callbacks.push(callback); + return { + observe: vi.fn(), + unobserve: vi.fn(), + disconnect: vi.fn() + }; + }) + }; +} diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000..4110ca1 --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,56 @@ +{ + // Visit https://aka.ms/tsconfig to read more about this file + "compilerOptions": { + // File Layout + "rootDir": "./", + "outDir": "./dist", + + // Environment Settings + // See also https://aka.ms/tsconfig/module + "module": "esnext", + "moduleResolution": "bundler", + "target": "es2022", + "lib": ["es2022", "dom", "dom.iterable"], + + // Other Outputs + "sourceMap": true, + "declaration": true, + "declarationMap": true, + + // Stricter Typechecking Options + "noUncheckedIndexedAccess": true, + "exactOptionalPropertyTypes": true, + + // Style Options + "noImplicitReturns": true, + "noImplicitOverride": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "noFallthroughCasesInSwitch": true, + + // Recommended Options + "strict": true, + "verbatimModuleSyntax": true, + "isolatedModules": true, + "moduleDetection": "force", + "skipLibCheck": true, + + // Path mapping + "baseUrl": "./", + "paths": { + "@/*": ["./"] + } + }, + "include": [ + "**/*.ts", + "**/*.js" + ], + "exclude": [ + "**/*.config.ts", + "test/**/*", + "node_modules", + "dist", + "**/*.test.ts", + "**/*.spec.ts" + ] +} diff --git a/types/README.md b/types/README.md new file mode 100644 index 0000000..35fb033 --- /dev/null +++ b/types/README.md @@ -0,0 +1,10 @@ +# Types 模块 + +## 架构设计 + +Types模块用于定义前端数据模型，提供给其他模块进行API或行为封装。 + +## 包含 + +1. **chat** + - 包 \ No newline at end of file diff --git a/types/chat/api.d.ts b/types/chat/api.d.ts new file mode 100644 index 0000000..093d146 --- /dev/null +++ b/types/chat/api.d.ts @@ -0,0 +1,96 @@ +import type { ChatSession, ChatMessage } from './base'; +import type { ChatMessageType } from './enum'; + +// 创建聊天会话请求接口 +export interface CreateChatSessionRequest { + participantId: string; +} + +// 更新聊天会话请求接口 +export interface UpdateChatSessionRequest { + sessionId: string; +} + +// 发送消息请求接口 +export interface SendMessageRequest { + sessionId: string; + content: string; + type: ChatMessageType; + metadata?: Record; +} + +// 获取聊天会话列表请求接口 +export interface GetChatSessionsRequest { + page?: number; + limit?: number; +} + +// 获取聊天会话列表响应接口 +export interface GetChatSessionsResponse { + sessions: ChatSession[]; + total: number; + page: number; + limit: number; +} + +// 获取聊天消息请求接口 +export interface GetChatMessagesRequest { + sessionId: string; + page?: number; + limit?: number; + before?: string; // 消息ID，获取该消息之前的消息 + after?: string; // 消息ID，获取该消息之后的消息 +} + +// 获取聊天消息响应接口 +export interface GetChatMessagesResponse { + messages: ChatMessage[]; + total: number; + page: number; + limit: number; + hasMore: boolean; +} + +// 标记消息已读请求接口 +export interface MarkMessagesAsReadRequest { + sessionId: string; + messageIds: string[]; +} + +// 标记消息已读响应接口 +export interface MarkMessagesAsReadResponse { + success: boolean; + markedMessageIds: string[]; // 成功标记的消息ID + failedMessageIds?: string[]; // 失败的消息ID +} + +// 搜索聊天消息请求接口 +export interface SearchChatMessagesRequest { + sessionId?: string; + query: string; + page?: number; + limit?: number; +} + +// 搜索聊天消息响应接口 +export interface SearchChatMessagesResponse { + messages: ChatMessage[]; + total: number; + page: number; + limit: number; +} + +// 搜索聊天会话请求接口 +export interface SearchChatSessionsRequest { + query: string; + page?: number; + limit?: number; +} + +// 搜索聊天会话响应接口 +export interface SearchChatSessionsResponse { + sessions: ChatSession[]; + total: number; + page: number; + limit: number; +} diff --git a/types/chat/base.d.ts b/types/chat/base.d.ts new file mode 100644 index 0000000..7bbe6d5 --- /dev/null +++ b/types/chat/base.d.ts @@ -0,0 +1,45 @@ +import type { User } from '../index'; +import type { ChatMessageType, ChatMessageStatus } from './enum'; + +// 聊天消息接口 +export interface ChatMessage { + id: string; + sessionId: string; + sender: User; + receiver: User; + content: string; + type: ChatMessageType; + status: ChatMessageStatus; + createdAt: Date; + // 非文本消息类型的元数据 + metadata?: { + fileName?: string; + fileSize?: number; + duration?: number; + thumbnail?: string; + [key: string]: unknown; + }; +} + +// 聊天会话接口 +export interface ChatSession { + id: string; + participant1Id: string; + participant2Id: string; + participant1: User; + participant2: User; + lastMessage?: { + id: string; + content: string; + senderId: string; + createdAt: Date; + }; + unreadCount1: number; // 参与者1的未读消息数 + unreadCount2: number; // 参与者2的未读消息数 + createdAt: Date; + updatedAt: Date; + // 会话元数据（特殊标记、背景设置、自定义属性等等） + metadata?: { + [key: string]: unknown; + }; +} diff --git a/types/chat/enum.d.ts b/types/chat/enum.d.ts new file mode 100644 index 0000000..ebe5000 --- /dev/null +++ b/types/chat/enum.d.ts @@ -0,0 +1,19 @@ +// 聊天消息类型枚举 +export enum ChatMessageType { + TEXT = 'text', + IMAGE = 'image', + FILE = 'file', + VOICE = 'voice', + VIDEO = 'video', + SYSTEM = 'system' +} + +// 聊天消息状态枚举 +export enum ChatMessageStatus { + SENDING = 'sending', + SENT = 'sent', + DELIVERED = 'delivered', + READ = 'read', + FAILED = 'failed' +} + diff --git a/types/chat/index.d.ts b/types/chat/index.d.ts new file mode 100644 index 0000000..cdcce8d --- /dev/null +++ b/types/chat/index.d.ts @@ -0,0 +1,3 @@ +export * from './enum'; +export * from './base'; +export * from './api'; diff --git a/types/index.d.ts b/types/index.d.ts new file mode 100644 index 0000000..28536d1 --- /dev/null +++ b/types/index.d.ts @@ -0,0 +1,5 @@ +// 导出所有类型定义模块 +export * from './chat'; +export * from './model'; +export * from './post'; +export * from './user'; diff --git a/types/model/api.d.ts b/types/model/api.d.ts new file mode 100644 index 0000000..0140b30 --- /dev/null +++ b/types/model/api.d.ts @@ -0,0 +1,160 @@ +import type { ModelComment, AIModel } from './base'; +import type { CommentSortType } from './enum'; + +// AI模型榜单项接口 +export interface AIModelRankingItem { + model: AIModel; + rank: number; + change?: 'up' | 'down' | 'same'; // 排名变化，未来扩展 +} + +// 获取AI模型广场数据请求接口 +export interface GetAIPlazaRequest { + // 模型卡片数据是静态配置（手动维护）的，不需要分页参数 +} + +// 获取AI模型广场数据响应接口 +export interface GetAIPlazaResponse { + models: AIModel[]; // 模型卡片列表，由管理员预定义 + hotRankings: AIModelRankingItem[]; // 热评模型榜单 + clickRankings: AIModelRankingItem[]; // 点击排行榜 +} + +// 获取模型详情请求接口 +export interface GetModelDetailRequest { + modelId: string; + page?: number; // 评论页码 + limit?: number; // 每页评论数量 + sortBy?: CommentSortType; // 评论排序方式，未来扩展功能 +} + +// 获取模型详情响应接口 +export interface GetModelDetailResponse { + model: AIModel; + comments: ModelComment[]; // 使用新的ModelComment类型，已经是数组 + totalComments: number; + hasMoreComments: boolean; // 是否还有更多评论，支持无限滚动加载 +} + +// 批量获取模型评论请求接口 +export interface GetModelCommentsRequest { + modelId: string; + page?: number; // 页码 + limit?: number; // 每页评论数量 + sortBy?: CommentSortType; // 评论排序方式 + parentId?: string; // 父评论ID，用于获取回复 +} + +// 批量获取模型评论响应接口 +export interface GetModelCommentsResponse { + comments: ModelComment[]; // 评论列表 + total: number; // 总数 + page: number; // 当前页码 + limit: number; // 每页数量 + hasMore: boolean; // 是否有更多数据 +} + +// 发表模型评论请求接口 +export interface CreateModelCommentRequest { + modelId: string; + content: string; + parentId?: string; // 父评论ID，用于回复评论 +} + +// 发表模型评论响应接口 +export interface CreateModelCommentResponse { + comment: ModelComment; // 使用新的ModelComment类型 +} + +// 点赞模型评论请求接口 +export interface LikeModelCommentRequest { + commentId: string; +} + +// 点赞模型评论响应接口 +export interface LikeModelCommentResponse { + success: boolean; +} + +// 记录模型点击请求接口 +export interface RecordModelClickRequest { + modelId: string; +} + +// 记录模型点击响应接口 +export interface RecordModelClickResponse { + success: boolean; + clickCount: number; // 更新后的总点击数 +} + +// 后面的都暂时不考虑 +// 删除模型评论请求接口 +export interface DeleteModelCommentRequest { + commentId: string; +} + +// 删除模型评论响应接口 +export interface DeleteModelCommentResponse { + success: boolean; +} + +// 更新模型评论请求接口 +export interface UpdateModelCommentRequest { + commentId: string; + content?: string; // 更新内容 +} + +// 更新模型评论响应接口 +export interface UpdateModelCommentResponse { + success: boolean; + comment: ModelComment; // 返回更新后的评论 +} + +// 批量点赞模型评论请求接口 +export interface BatchLikeModelCommentsRequest { + commentIds: string[]; // 评论ID列表 +} + +// 批量点赞模型评论响应接口 +export interface BatchLikeModelCommentsResponse { + results: Array<{ + commentId: string; + success: boolean; + comment?: ModelComment; // 成功时返回更新后的评论 + error?: string; // 失败时的错误信息 + }>; +} + +// 批量删除模型评论请求接口 +export interface BatchDeleteModelCommentsRequest { + commentIds: string[]; // 评论ID列表 +} + +// 批量删除模型评论响应接口 +export interface BatchDeleteModelCommentsResponse { + results: Array<{ + commentId: string; + success: boolean; + error?: string; // 失败时的错误信息 + }>; +} + +// 批量更新模型评论请求接口 +export interface BatchUpdateModelCommentsRequest { + updates: Array<{ + commentId: string; + content?: string; // 更新内容 + rating?: number; // 更新评分 + }>; +} + +// 批量更新模型评论响应接口 +export interface BatchUpdateModelCommentsResponse { + results: Array<{ + commentId: string; + success: boolean; + comment?: ModelComment; // 成功时返回更新后的评论 + error?: string; // 失败时的错误信息 + }>; +} + diff --git a/types/model/base.d.ts b/types/model/base.d.ts new file mode 100644 index 0000000..1967067 --- /dev/null +++ b/types/model/base.d.ts @@ -0,0 +1,31 @@ +import type { BaseEntity, BaseUser } from '../post/base'; + +// AI模型评论统计信息接口 +export interface ModelCommentStats { + stars: number; // 收藏数 + likes: number; // 点赞数 + comments: number; // 评论数 + replies: number; // 回复数 +} + +// AI模型评论接口 +export interface ModelComment extends BaseEntity { + modelId: string; // 模型ID + authorId: string; // 作者ID + author: BaseUser; // 作者信息 + content: string; // 评论内容 + parentId?: string; // 父评论ID，用于嵌套评论 + stats: ModelCommentStats; // 统计信息 +} + +// AI模型接口 +export interface AIModel { + id: string; + name: string; + description: string; + avatar?: string; // 模型头像 + tags?: string[]; // 模型标签 + website?: string; // 官方网站 + clickCount?: number; // 点击次数 + likeCount?: number; // 点赞次数 +} diff --git a/types/model/enum.d.ts b/types/model/enum.d.ts new file mode 100644 index 0000000..c0d79bd --- /dev/null +++ b/types/model/enum.d.ts @@ -0,0 +1,6 @@ +// AI模型评论排序枚举 +export enum CommentSortType { + LATEST = 'latest', // 最新 + HOTTEST = 'hottest', // 最热 + HIGHEST_RATING = 'highest_rating' // 评分最高 +} diff --git a/types/model/index.d.ts b/types/model/index.d.ts new file mode 100644 index 0000000..cb387c4 --- /dev/null +++ b/types/model/index.d.ts @@ -0,0 +1,4 @@ +// 导出所有模型相关的类型定义 +export * from './base'; +export * from './api'; +export * from './enum'; diff --git a/types/post/api.d.ts b/types/post/api.d.ts new file mode 100644 index 0000000..265e3ad --- /dev/null +++ b/types/post/api.d.ts @@ -0,0 +1,124 @@ +import type { BaseEntityContent, Post, PostComment } from './base'; +import type { + PostType, + PostSortBy, + CommentSortBy, + SortOrder +} from './enum'; + +// 创建帖子请求接口 +export interface CreatePostRequest extends BaseEntityContent { + type: PostType; // 帖子类型：提问或文章 + images?: string[]; // 图片 + publishedAt?: Date; // 发布时间 +} + +// 创建帖子响应接口 +export interface CreatePostResponse { + post: Post; +} + +// 获取帖子列表请求接口 +export interface GetPostsRequest { + page?: number; // 页码 + limit?: number; // 每页数量 + sortBy?: PostSortBy; // 帖子排序方式 + type?: PostType; // 帖子类型：提问或文章 + sortOrder?: SortOrder; // 排序方向 + authorId?: string; + search?: string; +} + +// 获取帖子列表响应接口 +export interface GetPostsResponse { + data: Post[]; // 数据列表 + total: number; // 总数 + page: number; // 当前页码 + limit: number; // 每页数量 + hasMore: boolean; // 是否有更多数据 + sortBy?: PostSortBy; // 帖子排序方式 +} + +// 获取帖子详情请求接口 +export interface GetPostRequest { + postId: string; +} + +// 获取帖子详情响应接口 +export interface GetPostResponse { + post: Post; +} + +// 点赞帖子请求接口 +export interface LikePostRequest { + postId: string; +} + +// 点赞帖子响应接口 +export interface LikePostResponse { + success: boolean; +} + +// 收藏帖子请求接口 +export interface BookmarkPostRequest { + postId: string; +} + +// 收藏帖子响应接口 +export interface BookmarkPostResponse { + success: boolean; +} + +// 创建评论请求接口 +export interface CreateCommentRequest { + postId: string; + content: string; + parentId?: string; +} + +// 创建评论响应接口 +export interface CreateCommentResponse { + comment: PostComment; +} + + +// 获取评论列表请求接口 +export interface GetCommentsRequest { + page?: number; // 页码 + limit?: number; // 每页数量 + sortOrder?: SortOrder; // 排序方向 + postId: string; + parentId?: string; + sortBy?: CommentSortBy; +} + +// 获取评论列表响应接口 +export interface GetCommentsResponse { + data: PostComment[]; // 数据列表 + total: number; // 总数 + page: number; // 当前页码 + limit: number; // 每页数量 + hasMore: boolean; // 是否有更多数据 +} + +// 点赞评论请求接口 +export interface LikeCommentRequest { + commentId: string; +} + +// 点赞评论响应接口 +export interface LikeCommentResponse { + success: boolean; +} + +// 后面全部暂时不考虑 +// 删除帖子请求接口 +export interface DeletePostRequest { + postId: string; +} + +// 删除帖子响应接口 +export interface DeletePostResponse { + success: boolean; +} + diff --git a/types/post/base.d.ts b/types/post/base.d.ts new file mode 100644 index 0000000..6de154f --- /dev/null +++ b/types/post/base.d.ts @@ -0,0 +1,41 @@ +import type {User} from '../user/base'; +import type {PostType} from './enum'; + +// 基础实体接口 +export interface BaseEntity { + id: string; // 唯一标识符 + createdAt: Date; // 创建时间 + updatedAt: Date; // 更新时间 +} + +// 用户基础信息接口 +export interface BaseUser { + user: User; +} + +export interface PostComment extends BaseEntity { + authorId: string; // 作者ID + author: BaseUser; // 作者信息 + content: string; // 评论内容 + parentId?: string; // 父评论ID，用于嵌套评论 +} + +// 实体内容和统计信息基础接口 +export interface BaseEntityContent { + title?: string; // 标题 + excerpt: string; // 摘要 + tags?: string[]; // 标签数组 + metadata?: Record; // 元数据 + stars: number; // 收藏数 + likes: number; // 点赞数 + comments: number; // 评论数 +} + +// 帖子接口 +export interface Post extends BaseEntity, BaseEntityContent { + type: PostType; // 帖子类型：提问或文章 + authorId: string; // 作者ID + author: BaseUser; // 作者信息 + images?: string[]; // 图片数组 + publishedAt?: Date; // 发布时间 +} diff --git a/types/post/enum.d.ts b/types/post/enum.d.ts new file mode 100644 index 0000000..74741c7 --- /dev/null +++ b/types/post/enum.d.ts @@ -0,0 +1,28 @@ +// 排序方式枚举 +export enum SortOrder { + ASC = 'asc', + DESC = 'desc' +} + +// 排序字段枚举 +export enum PostSortBy { + CREATED_AT = 'createdAt', + UPDATED_AT = 'updatedAt', + PUBLISHED_AT = 'publishedAt', + VIEWS = 'views', + LIKES = 'likes', + COMMENTS = 'comments' +} + +// 评论排序字段枚举 +export enum CommentSortBy { + CREATED_AT = 'createdAt', + LIKES = 'likes', + REPLIES = 'replies' +} + +// 帖子类型枚举 +export enum PostType { + QUESTION = 'question', + ARTICLE = 'article' +} diff --git a/types/post/index.d.ts b/types/post/index.d.ts new file mode 100644 index 0000000..2b5c3b1 --- /dev/null +++ b/types/post/index.d.ts @@ -0,0 +1,4 @@ +// 导出帖子系统所有类型定义 +export * from './base'; +export * from './enum'; +export * from './api'; diff --git a/types/user/base.d.ts b/types/user/base.d.ts new file mode 100644 index 0000000..10cd434 --- /dev/null +++ b/types/user/base.d.ts @@ -0,0 +1,52 @@ +import { NotificationType } from './enum'; + +// 最小用户信息 +export interface User{ + id: string; + username: string; +} + +// 认证 +export interface LoginRequest{ + username: string; + password: string; +} + +export interface LoginResponse{ + user: User; + sessionId: string; +} + +export interface RegisterRequest { + username: string; + email: string; + password: string; +} + +export interface RegisterResponse { + user: User; + sessionId: string; +} + +export interface ChangePasswordRequest { // 暂时用不到 + oldPassword: string; + newPassword: string; +} + +export interface RefreshTokenRequest { + sessionId: string; +} + +export interface RefreshTokenResponse { + sessionId: string; +} + +// 用户通知 +export interface UserNotification { // 暂时用不到 + id: string; + userId: string; + type: NotificationType; + content: string; + isRead: boolean; + createdAt: Date; +} diff --git a/types/user/enum.d.ts b/types/user/enum.d.ts new file mode 100644 index 0000000..c9cec8c --- /dev/null +++ b/types/user/enum.d.ts @@ -0,0 +1,8 @@ +// 通知类型枚举 +export enum NotificationType { + LIKE = 'like', + COMMENT = 'comment', + FOLLOW = 'follow', + MENTION = 'mention' +} + diff --git a/types/user/index.d.ts b/types/user/index.d.ts new file mode 100644 index 0000000..b0b0eb0 --- /dev/null +++ b/types/user/index.d.ts @@ -0,0 +1,4 @@ +export * from './base'; +export * from './profile'; +export * from './search'; +export * from './enum'; diff --git a/types/user/profile.d.ts b/types/user/profile.d.ts new file mode 100644 index 0000000..530726a --- /dev/null +++ b/types/user/profile.d.ts @@ -0,0 +1,36 @@ +import type { User } from './base'; + +// 用户档案以及更新 +export interface UserProfile{ + user: User; + avatar: string; + introduction: string; + level: string; +} + +export interface UserProfileUpdateRequest { + avatar?: string; + introduction?: string; + level?: string; +} + +export interface UserProfileUpdateResponse { + profile: UserProfile; +} + +// 用户关系 +export interface UserRelation { + id: string; + followerId: string[]; + followingId: string[]; +} + +export interface UserFollowRequest { + userId: string; +} + +export interface UserFollowResponse { + success: boolean; +} + + diff --git a/types/user/search.d.ts b/types/user/search.d.ts new file mode 100644 index 0000000..939a544 --- /dev/null +++ b/types/user/search.d.ts @@ -0,0 +1,12 @@ +import type { UserProfile } from './profile'; + +// 用户搜索结果 +export interface UserSearchRequest { + keyword: string; +} + +export interface UserSearchResponse { + users: Array + total: number; +} + diff --git a/utils/README.md b/utils/README.md new file mode 100644 index 0000000..082418b --- /dev/null +++ b/utils/README.md @@ -0,0 +1,35 @@ +# Utils 模块 + +## 架构设计 + +Utils 模块采用工具函数库模式，按功能域组织，提供常用的数据处理、字符串操作、日期处理和验证功能。 + +## 核心组件 + +1. **数据处理工具 (data.ts)** + - 深拷贝、防抖、节流等常用函数 + - 数组操作：去重、分组、排序、分页 + - 对象转换：数组转对象 + +2. **字符串处理工具 (string.ts)** + - 格式转换：驼峰、短横线、下划线命名 + - 字符串操作：截断、首字母大写、HTML处理 + - 工具函数：随机字符串、空值检查 + +3. **日期处理工具 (date.ts)** + - 日期格式化和相对时间计算 + - 日期比较：今天、昨天判断 + - 灵活的格式化模板 + +4. **验证工具 (validation.ts)** + - 常用验证：邮箱、手机号、URL、身份证 + - 数据验证：空值、范围、长度、类型 + - 日期和数字验证 + +## 设计原则 + +1. **纯函数**：所有工具函数都是纯函数，无副作用 +2. **类型安全**：充分利用 TypeScript 类型系统 +3. **模块化**：按功能域组织，按需导入 +4. **一致性**：统一的命名和参数设计 + diff --git a/utils/data.ts b/utils/data.ts new file mode 100644 index 0000000..51f4bf6 --- /dev/null +++ b/utils/data.ts @@ -0,0 +1,272 @@ +/** + * 节流函数 + * @param func 要节流的函数 + * @param wait 等待时间（毫秒） + * @param options 选项 + */ +export function throttle unknown>( + func: T, + wait: number, + options: { leading?: boolean; trailing?: boolean } = {} +): (...args: Parameters) => void { + let timeout: ReturnType | null = null; + let previous = 0; + + const { leading = true, trailing = true } = options; + + return function(this: unknown, ...args: Parameters) { + const now = Date.now(); + + if (!previous && !leading) previous = now; + + const remaining = wait - (now - previous); + + if (remaining <= 0 || remaining > wait) { + if (timeout) { + clearTimeout(timeout); + timeout = null; + } + previous = now; + func.apply(this, args); + } else if (!timeout && trailing) { + timeout = setTimeout(() => { + previous = leading ? Date.now() : 0; + timeout = null; + func.apply(this, args); + }, remaining); + } + }; +} + +/** + * 深拷贝函数 + * @param obj 要拷贝的对象 + * @returns 深拷贝后的对象 + */ +export const deepClone = (obj: T): T => { + if (obj === null || typeof obj !== 'object') { + return obj; + } + + // 处理日期对象 + if (obj instanceof Date) { + return new Date(obj.getTime()) as unknown as T; + } + + // 处理数组 + if (Array.isArray(obj)) { + return obj.map(item => deepClone(item)) as unknown as T; + } + + // 处理普通对象 + const clonedObj = {} as T; + for (const key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + clonedObj[key] = deepClone(obj[key]); + } + } + + return clonedObj; +}; + +/** + * 深度比较两个值是否相等 + * @param a 第一个值 + * @param b 第二个值 + * @returns 是否相等 + */ +export function deepEqual(a: unknown, b: unknown): boolean { + if (a === b) return true; + + if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) { + return false; + } + + const keysA = Object.keys(a as Record); + const keysB = Object.keys(b as Record); + + if (keysA.length !== keysB.length) return false; + + for (const key of keysA) { + if (!keysB.includes(key) || !deepEqual((a as Record)[key], (b as Record)[key])) { + return false; + } + } + + return true; +} + +/** + * 从对象中选取指定的属性 + * @param obj 源对象 + * @param keys 要选取的属性键数组 + * @returns 包含指定属性的新对象 + */ +export function pick, K extends keyof T>( + obj: T, + keys: K[] +): Pick { + const result = {} as Pick; + for (const key of keys) { + if (key in obj) { + result[key] = obj[key]; + } + } + return result; +} + +/** + * 从对象中排除指定的属性 + * @param obj 源对象 + * @param keys 要排除的属性键数组 + * @returns 排除指定属性后的新对象 + */ +export function omit, K extends keyof T>( + obj: T, + keys: K[] +): Omit { + const result = { ...obj } as T; + for (const key of keys) { + delete result[key]; + } + return result as Omit; +} + +/** + * 合并多个对象 + * @param objects 要合并的对象数组 + * @returns 合并后的新对象 + */ +export function merge>(...objects: Partial[]): T { + const result = {} as T; + + for (const obj of objects) { + if (obj && typeof obj === 'object') { + Object.assign(result, obj); + } + } + + return result; +} + +/** + * 将对象转换为查询字符串 + * @param obj 要转换的对象 + * @returns 查询字符串 + */ +export const toQueryString = (obj: Record): string => { + const params = new URLSearchParams(); + + for (const key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + const value = obj[key]; + if (value !== null && value !== undefined) { + params.append(key, String(value)); + } + } + } + + return params.toString(); +}; + +/** + * 将查询字符串转换为对象 + * @param queryString 查询字符串 + * @returns 转换后的对象 + */ +export const fromQueryString = (queryString: string): Record => { + const params = new URLSearchParams(queryString); + const result: Record = {}; + + for (const [key, value] of params.entries()) { + result[key] = value; + } + + return result; +}; + +/** + * 数组去重 + * @param array 要去重的数组 + * @param keyFn 可选的键函数，用于复杂对象去重 + * @returns 去重后的数组 + */ +export const unique = ( + array: T[], + keyFn?: (item: T) => K +): T[] => { + if (!keyFn) { + return [...new Set(array)]; + } + + const seen = new Set(); + return array.filter(item => { + const key = keyFn(item); + if (seen.has(key)) { + return false; + } + seen.add(key); + return true; + }); +}; + +/** + * 数组分组 + * @param array 要分组的数组 + * @param keyFn 分组键函数 + * @returns 分组后的对象 + */ +export const groupBy = ( + array: T[], + keyFn: (item: T) => K +): Record => { + return array.reduce((groups, item) => { + const key = keyFn(item); + if (!groups[key]) { + groups[key] = []; + } + groups[key].push(item); + return groups; + }, {} as Record); +}; + +/** + * 数组排序 + * @param array 要排序的数组 + * @param compareFn 比较函数 + * @returns 排序后的新数组 + */ +export const sortBy = ( + array: T[], + compareFn?: (a: T, b: T) => number +): T[] => { + return [...array].sort(compareFn); +}; + +/** + * 防抖函数 + * @param func 要防抖的函数 + * @param wait 等待时间（毫秒） + * @param immediate 是否立即执行 + */ +export function debounce unknown>( + func: T, + wait: number, + immediate = false +): (...args: Parameters) => void { + let timeout: ReturnType | null = null; + + return function(this: unknown, ...args: Parameters) { + const later = () => { + timeout = null; + if (!immediate) func.apply(this, args); + }; + + const callNow = immediate && !timeout; + + if (timeout) clearTimeout(timeout); + timeout = setTimeout(later, wait); + + if (callNow) func.apply(this, args); + }; +} diff --git a/utils/date.ts b/utils/date.ts new file mode 100644 index 0000000..d1420da --- /dev/null +++ b/utils/date.ts @@ -0,0 +1,83 @@ +// 日期格式化工具 +export const dateUtils = { + // 格式化日期 + formatDate: (date: Date | string, format = 'YYYY-MM-DD'): string => { + const d = new Date(date); + + if (isNaN(d.getTime())) { + return ''; + } + + const year = d.getFullYear(); + const month = String(d.getMonth() + 1).padStart(2, '0'); + const day = String(d.getDate()).padStart(2, '0'); + const hours = String(d.getHours()).padStart(2, '0'); + const minutes = String(d.getMinutes()).padStart(2, '0'); + const seconds = String(d.getSeconds()).padStart(2, '0'); + + return format + .replace('YYYY', String(year)) + .replace('MM', month) + .replace('DD', day) + .replace('HH', hours) + .replace('mm', minutes) + .replace('ss', seconds); + }, + + // 获取相对时间（如：2小时前） + getRelativeTime: (date: Date | string): string => { + const now = new Date(); + const target = new Date(date); + const diffMs = now.getTime() - target.getTime(); + + // 如果目标时间在未来，返回绝对时间 + if (diffMs < 0) { + return dateUtils.formatDate(target, 'YYYY-MM-DD HH:mm'); + } + + const diffSeconds = Math.floor(diffMs / 1000); + const diffMinutes = Math.floor(diffSeconds / 60); + const diffHours = Math.floor(diffMinutes / 60); + const diffDays = Math.floor(diffHours / 24); + const diffWeeks = Math.floor(diffDays / 7); + const diffMonths = Math.floor(diffDays / 30); + const diffYears = Math.floor(diffDays / 365); + + if (diffSeconds < 60) { + return '刚刚'; + } else if (diffMinutes < 60) { + return `${diffMinutes}分钟前`; + } else if (diffHours < 24) { + return `${diffHours}小时前`; + } else if (diffDays < 7) { + return `${diffDays}天前`; + } else if (diffWeeks < 4) { + return `${diffWeeks}周前`; + } else if (diffMonths < 12) { + return `${diffMonths}个月前`; + } else { + return `${diffYears}年前`; + } + }, + + // 检查是否是今天 + isToday: (date: Date | string): boolean => { + const today = new Date(); + const target = new Date(date); + + return today.getFullYear() === target.getFullYear() && + today.getMonth() === target.getMonth() && + today.getDate() === target.getDate(); + }, + + // 检查是否是昨天 + isYesterday: (date: Date | string): boolean => { + const yesterday = new Date(); + yesterday.setDate(yesterday.getDate() - 1); + const target = new Date(date); + + return yesterday.getFullYear() === target.getFullYear() && + yesterday.getMonth() === target.getMonth() && + yesterday.getDate() === target.getDate(); + } +}; diff --git a/utils/index.ts b/utils/index.ts new file mode 100644 index 0000000..1c72578 --- /dev/null +++ b/utils/index.ts @@ -0,0 +1,5 @@ +// 导出所有工具函数 +export * from './date'; +export * from './string'; +export * from './data'; +export * from './validation'; diff --git a/utils/string.ts b/utils/string.ts new file mode 100644 index 0000000..3dc9ee1 --- /dev/null +++ b/utils/string.ts @@ -0,0 +1,90 @@ +// 字符串格式化工具 +export const stringUtils = { + // 截断字符串并添加省略号 + truncate: (str: string, maxLength: number, suffix = '...'): string => { + if (str.length<=maxLength) return str; + // 计算截断位置，确保结果不超过最大长度 + const truncateLength = maxLength - suffix.length; + return str.substring(0, truncateLength) + suffix; + }, + + // 首字母大写 + capitalize: (str: string): string => { + if (!str) return ''; + return str.charAt(0).toUpperCase() + str.slice(1); + }, + + // 驼峰命名转换 + toCamelCase: (str: string): string => { + if (!str) return ''; + + // 先检查字符串是否已经是驼峰命名（首字母小写，无分隔符） + const isAlreadyCamelCase = /^[a-z][a-zA-Z0-9]*$/.test(str); + if (isAlreadyCamelCase) { + return str; + } + + // 处理短横线、下划线和空格分隔的情况 + return str + // 先将整个字符串转换为小写 + .toLowerCase() + // 将所有分隔符后的首字母大写 + .replace(/[-_\s]+(.)/g, (_, char) => char ? char.toUpperCase() : ''); + }, + + // 短横线命名转换 + toKebabCase: (str: string): string => { + if (!str) return ''; + return str // 先将下划线和空格替换为短横线 + .replace(/[_\s]+/g, '-') + // 处理驼峰命名：在小写字母或数字后跟大写字母时插入短横线 + .replace(/([a-z0-9])([A-Z])/g, '$1-$2') + // 处理连续大写字母的情况（如HTMLParser -> html-parser） + .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2') + // 转换为全小写 + .toLowerCase(); + }, + + // 下划线命名转换 + toSnakeCase: (str: string): string => { + if (!str) return ''; + return str // 先将短横线和空格替换为下划线 + .replace(/[-\s]+/g, '_') + // 处理驼峰命名：在小写字母或数字后跟大写字母时插入下划线 + .replace(/([a-z0-9])([A-Z])/g, '$1_$2') + // 处理连续大写字母的情况（如HTMLParser -> html_parser） + .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2') + // 转换为全小写 + .toLowerCase(); + }, + + // 转义HTML特殊字符 + escapeHtml: (text: string): string => { + const map: Record = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''' + }; + + return text.replace(/[&<>"']/g, (m) => map[m] || m); + }, + + // 生成随机字符串 + randomString: (length = 10): string => { + const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'; + let result = ''; + + for (let i = 0; i < length; i++) { + result += chars.charAt(Math.floor(Math.random() * chars.length)); + } + + return result; + }, + + // 检查是否为空字符串（包括只有空白字符的字符串） + isEmpty: (str: string | null | undefined): boolean => { + return !str || str.trim().length === 0; + } +}; diff --git a/utils/validation.ts b/utils/validation.ts new file mode 100644 index 0000000..ab82cb6 --- /dev/null +++ b/utils/validation.ts @@ -0,0 +1,110 @@ +// 验证工具 +export const validationUtils = { + // 验证邮箱格式 + isEmail: (email: string): boolean => { + const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/; + return emailRegex.test(email); + }, + + // 验证手机号格式（中国大陆） + isPhoneNumber: (phone: string): boolean => { + const phoneRegex = /^1[3-9]\d{9}$/; + return phoneRegex.test(phone); + }, + + // 验证身份证号格式（中国大陆） + isIdCard: (idCard: string): boolean => { + const idCardRegex = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/; + return idCardRegex.test(idCard); + }, + + // 验证密码强度 + isStrongPassword: (password: string): boolean => { + // 至少8位，包含大小写字母、数字和特殊字符 + const strongPasswordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/; + return strongPasswordRegex.test(password); + }, + + // 验证是否为空 + isEmpty: (value: unknown): boolean => { + if (value === null || value === undefined) { + return true; + } + + if (typeof value === 'string') { + return value.trim() === ''; + } + + if (Array.isArray(value)) { + return value.length === 0; + } + + if (typeof value === 'object') { + return Object.keys(value as Record).length === 0; + } + + return false; + }, + + // 验证数字范围 + isInRange: (value: number, min: number, max: number): boolean => { + return value >= min && value <= max; + }, + + // 验证字符串长度 + isLengthValid: (str: string, minLength: number, maxLength?: number): boolean => { + const length = str.length; + if (length < minLength) return false; + if (maxLength && length > maxLength) return false; + return true; + }, + + // 验证是否为数字 + isNumber: (value: unknown): value is number => { + return typeof value === 'number' && !isNaN(value); + }, + + // 验证是否为整数 + isInteger: (value: unknown): value is number => { + return validationUtils.isNumber(value) && Number.isInteger(value); + }, + + // 验证是否为正数 + isPositive: (value: number): boolean => { + return value > 0; + }, + + // 验证是否为负数 + isNegative: (value: number): boolean => { + return value < 0; + }, + + // 验证是否为偶数 + isEven: (value: number): boolean => { + return value % 2 === 0; + }, + + // 验证是否为奇数 + isOdd: (value: number): boolean => { + return value % 2 !== 0; + }, + + // 验证是否为闰年 + isLeapYear: (year: number): boolean => { + return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0; + }, + + // 验证日期是否有效 + isValidDate: (date: Date | string): boolean => { + const d = new Date(date); + + // 检查日期是否有效 + if (isNaN(d.getTime())) { + return false; + } + + return true; + } +}; + + diff --git a/vitest.config.ts b/vitest.config.ts new file mode 100644 index 0000000..1e67ceb --- /dev/null +++ b/vitest.config.ts @@ -0,0 +1,37 @@ +import { defineConfig } from 'vitest/config'; +import path from 'path'; + +export default defineConfig({ + resolve: { + alias: { + '@': path.resolve(__dirname, './'), + }, + }, + test: { + globals: true, + environment: 'node', + coverage: { + provider: 'v8', + reporter: ['text', 'json', 'html'], + exclude: [ + 'node_modules/', + 'dist/', + '**/*.config.js', + '**/*.config.ts', + '**/*.d.ts', + '**/index.ts', + '**/*.test.ts', + '**/*.spec.ts', + 'test/**', // 排除整个test目录 + ], + thresholds: { + global: { + branches: 80, + functions: 80, + lines: 80, + statements: 80, + }, + }, + }, + }, +}); \ No newline at end of file