临时完整优化

This commit is contained in:
Chen committed 2025-12-01 13:42:25 +08:00
1 parent 9e346c7d5b
commit d6b4919880
29 files changed
+5228 -400

No files matched your search

@@ -0,0 +1,484 @@
# Design Document
## Overview
本设计文档描述素材库切换性能优化的技术方案。核心思路是将"一次性加载全部数据"改为"按需分批加载",并引入健壮的请求管理机制来处理取消、竞态和空闲加载。
## Architecture
### 整体架构
```
┌─────────────────────────────────────────────────────────────┐
│ Frontend │
│ ┌─────────────┐ ┌──────────────┐ ┌───────────────────┐ │
│ │ Sidebar │ │ MainContent │ │ ImageWaterfall │ │
│ │ (文件夹树) │ │ (协调加载) │ │ (虚拟滚动) │ │
│ └──────┬──────┘ └──────┬───────┘ └─────────┬─────────┘ │
│ │ │ │ │
│ └────────────────┼─────────────────────┘ │
│ ▼ │
│ ┌───────────────────────┐ │
│ │ RequestManager │ │
│ │ (请求管理/取消/队列) │ │
│ └───────────┬───────────┘ │
│ │ │
│ ┌───────────────────────┐ │
│ │ ImageLoadService │ │
│ │ (分批加载/空闲加载) │ │
│ └───────────┬───────────┘ │
└──────────────────────────┼──────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ Backend │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Image API (分页支持) │ │
│ │ GET /api/image?libraryId=x&folder=y&offset=0&limit=200│ │
│ └─────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
```
### 数据流
```mermaid
sequenceDiagram
participant User
participant Sidebar
participant RequestManager
participant ImageLoadService
participant Backend
User->>Sidebar: 点击文件夹A
Sidebar->>RequestManager: loadFolder(A)
RequestManager->>RequestManager: 取消之前的请求
RequestManager->>ImageLoadService: fetchBatch(A, offset=0)
ImageLoadService->>Backend: GET /api/image?folder=A&offset=0&limit=200
Backend-->>ImageLoadService: 返回前200张
ImageLoadService-->>Sidebar: 更新UI显示
Note over ImageLoadService: 用户空闲时
ImageLoadService->>Backend: GET /api/image?folder=A&offset=200&limit=200
Backend-->>ImageLoadService: 返回下一批
ImageLoadService-->>Sidebar: 追加到列表
```
## Components and Interfaces
### 1. RequestManager (新增)
负责管理所有异步请求的生命周期。
```typescript
interface RequestManager {
// 创建一个新的请求上下文
createRequest(type: 'library' | 'folder' | 'images'): RequestContext;
// 取消指定类型的所有请求
cancelAll(type: 'library' | 'folder' | 'images'): void;
// 取消所有请求
cancelAllRequests(): void;
// 检查请求是否仍然有效
isValid(requestId: string): boolean;
}
interface RequestContext {
id: string;
abortController: AbortController;
signal: AbortSignal;
isActive: boolean;
cancel(): void;
}
```
### 2. ImageLoadService (新增)
负责图片的分批加载和空闲加载逻辑。
```typescript
interface ImageLoadService {
// 加载文件夹的第一批图片
loadInitialBatch(libraryId: string, folder: string | null): Promise<ImageBatch>;
// 加载下一批图片
loadNextBatch(): Promise<ImageBatch>;
// 开始空闲加载
startIdleLoading(): void;
// 暂停空闲加载
pauseIdleLoading(): void;
// 获取加载状态
getLoadingState(): LoadingState;
}
interface ImageBatch {
images: Image[];
offset: number;
total: number;
hasMore: boolean;
}
interface LoadingState {
isLoading: boolean;
loadedCount: number;
totalCount: number;
currentFolder: string | null;
}
```
### 3. 后端 API 扩展
```typescript
// 扩展现有的 GET /api/image 接口
interface ImageSearchParams {
libraryId: string;
folder?: string;
keywords?: string;
offset?: number; // 新增:分页偏移
limit?: number; // 新增:每页数量
// ... 其他现有参数
}
interface ImageSearchResponse {
images: Image[];
total: number; // 新增:总数
offset: number; // 新增:当前偏移
hasMore: boolean; // 新增:是否有更多
}
```
### 4. Store 扩展
```typescript
// useStore 新增状态
interface ImageLoadingState {
// 当前加载状态
isLoadingImages: boolean;
loadedImageCount: number;
totalImageCount: number;
hasMoreImages: boolean;
// 当前加载上下文
currentLoadContext: {
libraryId: string | null;
folder: string | null;
requestId: string | null;
};
}
```
### 5. CacheService (新增)
负责图片元数据的本地文件缓存。
```typescript
interface CacheService {
// 获取素材库缓存
getLibraryCache(libraryId: string): Promise<LibraryCache | null>;
// 保存素材库缓存
saveLibraryCache(libraryId: string, data: LibraryCache): Promise<void>;
// 验证缓存是否有效
validateCache(libraryId: string): Promise<CacheValidation>;
// 获取文件夹缓存
getFolderCache(libraryId: string, folder: string): Promise<FolderCache | null>;
// 保存文件夹缓存
saveFolderCache(libraryId: string, folder: string, images: Image[]): Promise<void>;
// 清除缓存
invalidateCache(libraryId: string): Promise<void>;
}
interface LibraryCache {
version: number; // 缓存版本号
libraryId: string;
createdAt: number; // 缓存创建时间
dbModifiedAt: number; // 数据库最后修改时间
totalCount: number; // 总图片数
folders: FolderSummary[]; // 文件夹摘要(不含图片详情)
}
interface FolderCache {
folder: string;
images: Image[];
cachedAt: number;
imageCount: number;
}
interface CacheValidation {
isValid: boolean;
reason?: 'not_found' | 'stale' | 'corrupted';
dbModifiedAt?: number;
cacheModifiedAt?: number;
}
```
### 6. 后端缓存 API (新增)
```typescript
// 获取缓存元数据
// GET /api/cache/meta/:libraryId
interface CacheMetaResponse {
dbModifiedAt: number; // 数据库最后修改时间戳
totalImages: number;
totalFolders: number;
}
// 获取完整缓存数据(用于初始化)
// GET /api/cache/full/:libraryId
interface FullCacheResponse {
meta: CacheMetaResponse;
folders: FolderTree[];
// 注意:不返回所有图片,只返回文件夹结构
}
// 获取文件夹图片(带缓存头)
// GET /api/image?libraryId=x&folder=y&offset=0&limit=200
// Response Header: X-Folder-Modified: timestamp
```
## Data Models
### 请求上下文
```typescript
interface RequestContext {
id: string; // 唯一请求ID (UUID)
type: 'library' | 'folder' | 'images';
createdAt: number; // 创建时间戳
abortController: AbortController;
status: 'pending' | 'completed' | 'cancelled' | 'error';
}
```
### 加载队列项
```typescript
interface LoadQueueItem {
libraryId: string;
folder: string | null;
offset: number;
limit: number;
priority: 'high' | 'normal' | 'idle';
requestContext: RequestContext;
}
```
### 缓存文件结构
缓存文件存储在 `.flypic/cache/` 目录下:
```
.flypic/
├── metadata.db # SQLite 数据库
├── thumbnails/ # 缩略图
└── cache/ # 新增:缓存目录
├── library.json # 素材库级别缓存(文件夹树+元数据)
└── folders/ # 文件夹级别缓存
├── {hash1}.json # 文件夹图片列表缓存
└── {hash2}.json
```
### 缓存文件格式
```typescript
// library.json
interface LibraryCacheFile {
version: 1;
libraryId: string;
createdAt: number;
dbModifiedAt: number;
totalCount: number;
folderTree: FolderNode[];
}
// folders/{hash}.json
interface FolderCacheFile {
version: 1;
folder: string;
cachedAt: number;
folderModifiedAt: number; // 该文件夹最后修改时间
images: ImageMetadata[]; // 精简的图片元数据
}
// 精简的图片元数据(减少缓存大小)
interface ImageMetadata {
id: number;
path: string;
filename: string;
width: number;
height: number;
thumbnail_path: string;
file_type: string;
created_at: number;
}
```
## 缓存策略
### 缓存失效判断
```mermaid
flowchart TD
A[切换素材库] --> B{缓存文件存在?}
B -->|否| C[从数据库加载]
B -->|是| D[读取缓存]
D --> E{获取DB修改时间}
E --> F{缓存时间 >= DB修改时间?}
F -->|是| G[使用缓存数据]
F -->|否| H[缓存失效,重新加载]
G --> I[后台校验增量变化]
H --> C
C --> J[保存到缓存]
```
### 增量更新
当检测到数据库有变化时,不需要完全重建缓存:
1. 比较 `indexed_at` 时间戳找出新增/修改的图片
2. 比较文件夹列表找出新增/删除的文件夹
3. 只更新变化的部分
## Correctness Properties
*A property is a characteristic or behavior that should hold true across all valid executions of a system-essentially, a formal statement about what the system should do. Properties serve as the bridge between human-readable specifications and machine-verifiable correctness guarantees.*
### Property 1: Request cancellation on library switch
*For any* library switch operation, all pending requests from the previous library should be cancelled (aborted) before new requests are initiated.
**Validates: Requirements 1.2**
### Property 2: Memory cleanup on library switch
*For any* library switch operation, the previous library's image data should be cleared from the store state, and the new state should only contain data from the new library.
**Validates: Requirements 1.3**
### Property 3: Request cancellation on folder switch
*For any* folder selection while a previous folder's images are still loading, the previous folder's loading request should be cancelled.
**Validates: Requirements 2.2**
### Property 4: Scroll triggers batch loading
*For any* folder with more images than the initial batch size, scrolling to the bottom should trigger loading of the next batch.
**Validates: Requirements 2.3**
### Property 5: Debounce rapid folder clicks
*For any* sequence of rapid folder clicks (within debounce window), only the final folder selection should result in a completed request.
**Validates: Requirements 3.2**
### Property 6: Background loading pauses on user action
*For any* user-initiated action (folder click, library switch) while background loading is in progress, the background loading should pause until the user action completes.
**Validates: Requirements 3.3**
### Property 7: Unique request IDs
*For any* set of requests created by RequestManager, each request should have a unique ID that is different from all other request IDs.
**Validates: Requirements 4.1**
### Property 8: Cancelled requests don't trigger callbacks
*For any* cancelled request, its completion callback should not be executed, and its result should not be applied to the state.
**Validates: Requirements 4.2**
### Property 9: Only latest request result applied
*For any* sequence of requests for the same resource (folder/library), only the result of the most recently initiated request should be applied to the state, regardless of completion order.
**Validates: Requirements 4.3**
### Property 10: Unmount cancels all requests
*For any* component unmount event, all pending requests associated with that component should be cancelled.
**Validates: Requirements 4.4**
### Property 11: Batch loading updates display incrementally
*For any* batch load completion, the displayed image count should increase by the batch size (or remaining count if less).
**Validates: Requirements 5.2**
### Property 12: Cache file creation after full load
*For any* library that completes full image loading, a cache file should exist in the .flypic/cache directory.
**Validates: Requirements 6.1**
### Property 13: Cache used when valid
*For any* library switch where valid cache exists (cache timestamp >= db modification timestamp), the images should be loaded from cache without database query.
**Validates: Requirements 6.2**
### Property 14: Cache validation compares timestamps
*For any* cache validation operation, the system should compare the cache's dbModifiedAt timestamp with the current database modification timestamp.
**Validates: Requirements 6.3**
### Property 15: Stale cache triggers reload
*For any* cache where dbModifiedAt < current database modification timestamp, the cache should be invalidated and data should be reloaded from database.
**Validates: Requirements 6.4**
### Property 16: Folder cache creation
*For any* folder whose images are fully loaded, a separate cache file should be created for that folder.
**Validates: Requirements 7.1**
### Property 17: Folder cache invalidation on content change
*For any* folder whose content changes (images added/removed), the folder's cache should be invalidated on next access.
**Validates: Requirements 7.3**
### Property 18: LRU cache eviction
*For any* state where folder cache count exceeds the maximum threshold, the least recently used folder cache should be evicted first.
**Validates: Requirements 7.4**
## Error Handling
### 网络错误
- 请求超时:显示重试按钮,允许用户手动重试
- 网络断开:显示离线提示,使用缓存数据(如果可用)
### 缓存错误
- 缓存文件损坏:删除损坏的缓存,从数据库重新加载
- 缓存写入失败:记录警告日志,继续正常运行(缓存是优化,不是必需)
### 并发错误
- 竞态条件:通过 requestId 机制确保只应用最新请求的结果
- 重复请求:通过 debounce 和请求去重避免
## Testing Strategy
### 单元测试
使用 Vitest 进行单元测试:
1. **RequestManager 测试**
- 测试请求创建和 ID 唯一性
- 测试请求取消功能
- 测试按类型取消请求
2. **CacheService 测试**
- 测试缓存文件读写
- 测试缓存验证逻辑
- 测试缓存失效判断
3. **ImageLoadService 测试**
- 测试分批加载逻辑
- 测试空闲加载触发
### 属性测试
使用 fast-check 进行属性测试:
1. **请求管理属性测试**
- Property 7: 生成随机数量的请求,验证所有 ID 唯一
- Property 8: 生成请求序列,取消部分,验证回调行为
- Property 9: 生成乱序完成的请求,验证只应用最新结果
2. **缓存属性测试**
- Property 14/15: 生成随机时间戳组合,验证缓存验证逻辑
- Property 18: 生成随机访问序列,验证 LRU 驱逐顺序
### 集成测试
1. **素材库切换流程测试**
- 模拟切换素材库,验证请求取消和状态清理
2. **文件夹导航测试**
- 模拟快速点击多个文件夹,验证 debounce 和取消逻辑
3. **缓存集成测试**
- 测试完整的缓存创建、读取、失效流程
@@ -0,0 +1,95 @@
# Requirements Document
## Introduction
本文档定义了素材库切换性能优化的需求。当前系统在切换到大型素材库(如5万张图片)时存在严重的性能问题,表现为20-30秒的UI卡顿。优化目标是实现流畅的素材库切换体验,即使面对大量图片也能保持响应性。
## Glossary
- **素材库 (Library)**: 用户添加的图片文件夹,包含图片索引数据库
- **文件夹树 (Folder Tree)**: 素材库内的文件夹层级结构
- **虚拟滚动 (Virtual Scroll)**: 只渲染可视区域内的元素,减少DOM节点数量
- **分页加载 (Pagination)**: 分批次加载数据,而非一次性加载全部
- **请求取消 (Request Cancellation)**: 当用户切换操作时,取消之前未完成的请求
- **空闲加载 (Idle Loading)**: 在用户无操作时后台预加载数据
- **AbortController**: Web API,用于取消 fetch 请求
## Requirements
### Requirement 1
**User Story:** As a user, I want to switch between libraries quickly, so that I can browse different image collections without waiting.
#### Acceptance Criteria
1. WHEN a user clicks on a different library THEN the System SHALL display the folder tree within 500ms
2. WHEN a user switches libraries THEN the System SHALL cancel any pending image loading requests from the previous library
3. WHEN a user switches libraries THEN the System SHALL clear the previous library's image data from memory before loading new data
4. WHEN switching to a large library (>10000 images) THEN the System SHALL show a loading indicator instead of freezing the UI
### Requirement 2
**User Story:** As a user, I want to click on folders and see images immediately, so that I can browse my collection efficiently.
#### Acceptance Criteria
1. WHEN a user selects a folder THEN the System SHALL load and display the first batch of images within 300ms
2. WHEN a user selects a different folder while images are loading THEN the System SHALL cancel the previous folder's loading request
3. WHEN a folder contains more images than the initial batch THEN the System SHALL load additional images as the user scrolls
4. WHEN the user stops scrolling THEN the System SHALL continue loading remaining images in the background during idle time
### Requirement 3
**User Story:** As a user, I want the application to remain responsive while loading large amounts of data, so that I can continue interacting with the UI.
#### Acceptance Criteria
1. WHEN loading images THEN the System SHALL process data in chunks to avoid blocking the main thread for more than 50ms
2. WHEN multiple rapid folder clicks occur THEN the System SHALL debounce requests and only execute the final selection
3. WHEN background loading is in progress THEN the System SHALL pause background loading when user initiates a new action
4. WHEN an error occurs during loading THEN the System SHALL display an error message and allow retry
### Requirement 4
**User Story:** As a developer, I want a robust request management system, so that concurrent requests do not cause race conditions or memory leaks.
#### Acceptance Criteria
1. WHEN a new request is initiated THEN the System SHALL assign a unique request ID for tracking
2. WHEN a request is cancelled THEN the System SHALL clean up associated resources and pending callbacks
3. WHEN multiple requests complete out of order THEN the System SHALL only apply the result of the most recent request
4. WHEN the component unmounts THEN the System SHALL cancel all pending requests
### Requirement 5
**User Story:** As a user, I want to see progress feedback when loading large folders, so that I know the application is working.
#### Acceptance Criteria
1. WHEN loading a folder with more than 500 images THEN the System SHALL display a progress indicator showing loaded count
2. WHEN images are being loaded in batches THEN the System SHALL update the display incrementally as each batch completes
3. WHEN all images are loaded THEN the System SHALL hide the progress indicator
### Requirement 6
**User Story:** As a user, I want the application to remember my library data between sessions, so that switching libraries is instant without re-querying the database.
#### Acceptance Criteria
1. WHEN a library's image list is fully loaded THEN the System SHALL cache the image metadata to a local file in the .flypic folder
2. WHEN switching to a library with existing cache THEN the System SHALL load from cache file first and display within 200ms
3. WHEN cache exists THEN the System SHALL verify cache validity by comparing database modification timestamp
4. WHEN cache is stale (database modified after cache) THEN the System SHALL invalidate cache and reload from database
5. WHEN new images are added or removed THEN the System SHALL update the cache file incrementally
### Requirement 7
**User Story:** As a user, I want folder-level caching, so that clicking on previously visited folders is instant.
#### Acceptance Criteria
1. WHEN a folder's images are loaded THEN the System SHALL cache that folder's image list separately
2. WHEN clicking a cached folder THEN the System SHALL display cached images immediately
3. WHEN the folder's content changes THEN the System SHALL detect the change and refresh the cache
4. WHEN memory usage exceeds threshold THEN the System SHALL evict least recently used folder caches
@@ -0,0 +1,229 @@
# Implementation Plan
- [x] 1. 后端 API 扩展 - 支持分页和缓存元数据
- [x] 1.1 扩展图片搜索 API 支持分页参数
- 修改 `backend/routes/image.js` 的 GET `/` 接口
- 添加 `offset` 和 `limit` 参数支持
- 返回 `total`、`hasMore` 字段
- _Requirements: 2.3_
- [x] 1.2 添加缓存元数据 API
- 新增 GET `/api/cache/meta/:libraryId` 接口
- 返回数据库最后修改时间戳
- _Requirements: 6.3_
- [x] 1.3 修改数据库记录修改时间
- 在 `backend/database/db.js` 添加 `last_modified` 表或字段
- 每次插入/更新/删除图片时更新时间戳
- _Requirements: 6.3, 6.4_
- [x] 2. 前端请求管理器 - RequestManager
- [x] 2.1 创建 RequestManager 服务
- 新建 `frontend/src/services/requestManager.js`
- 实现 `createRequest`、`cancelAll`、`isValid` 方法
- 使用 AbortController 管理请求取消
- _Requirements: 4.1, 4.2_
- [x] 2.2 编写 RequestManager 属性测试
- **Property 7: Unique request IDs**
- **Validates: Requirements 4.1**
- [x] 2.3 编写请求取消属性测试
- **Property 8: Cancelled requests don't trigger callbacks**
- **Validates: Requirements 4.2**
- [x] 3. 前端缓存服务 - CacheService
- [x] 3.1 创建 CacheService 服务
- 新建 `frontend/src/services/cacheService.js`
- 实现缓存读取、写入、验证方法
- 使用 localStorage 或 IndexedDB 存储缓存元数据
- _Requirements: 6.1, 6.2_
- [x] 3.2 实现缓存验证逻辑
- 比较缓存时间戳与数据库修改时间
- 实现缓存失效判断
- _Requirements: 6.3, 6.4_
- [x] 3.3 编写缓存验证属性测试
- **Property 14: Cache validation compares timestamps**
- **Property 15: Stale cache triggers reload**
- **Validates: Requirements 6.3, 6.4**
- [x] 4. 后端缓存文件管理
- [x] 4.1 创建缓存文件读写工具
- 新建 `backend/utils/cacheManager.js`
- 实现 `.flypic/cache/` 目录下的文件读写
- _Requirements: 6.1, 7.1_
- [x] 4.2 添加缓存 API 路由
- 新建 `backend/routes/cache.js`
- GET `/api/cache/library/:libraryId` - 获取素材库缓存
- POST `/api/cache/library/:libraryId` - 保存素材库缓存
- GET `/api/cache/folder/:libraryId/:folderHash` - 获取文件夹缓存
- _Requirements: 6.1, 6.2, 7.1, 7.2_
- [x] 4.3 编写缓存文件创建属性测试
- **Property 12: Cache file creation after full load**
- **Property 16: Folder cache creation**
- **Validates: Requirements 6.1, 7.1**
- [x] 5. Checkpoint - 确保基础设施测试通过
- Ensure all tests pass, ask the user if questions arise.
- [x] 6. 前端图片加载服务 - ImageLoadService
- [x] 6.1 创建 ImageLoadService 服务
- 新建 `frontend/src/services/imageLoadService.js`
- 实现 `loadInitialBatch`、`loadNextBatch` 方法
- 集成 RequestManager 进行请求管理
- _Requirements: 2.1, 2.3_
- [x] 6.2 实现空闲加载逻辑
- 使用 `requestIdleCallback` 或 `setTimeout` 实现空闲检测
- 在空闲时继续加载剩余图片
- _Requirements: 2.4_
- [x] 6.3 实现缓存优先加载
- 切换素材库/文件夹时先检查缓存
- 缓存有效则直接使用,无效则从 API 加载
- _Requirements: 6.2, 7.2_
- [x] 6.4 编写分批加载属性测试
- **Property 4: Scroll triggers batch loading**
- **Property 11: Batch loading updates display incrementally**
- **Validates: Requirements 2.3, 5.2**
- [x] 7. 重构 Sidebar 组件 - 素材库切换
- [x] 7.1 重构 handleLibraryClick 函数
- 集成 RequestManager 取消之前的请求
- 清理之前素材库的状态
- 优先从缓存加载
- _Requirements: 1.2, 1.3, 6.2_
- [x] 7.2 编写素材库切换属性测试
- **Property 1: Request cancellation on library switch**
- **Property 2: Memory cleanup on library switch**
- **Validates: Requirements 1.2, 1.3**
- [x] 8. 重构 MainContent 组件 - 文件夹切换
- [x] 8.1 重构 loadImages 函数
- 集成 ImageLoadService 进行分批加载
- 实现请求取消和 debounce
- _Requirements: 2.1, 2.2, 3.2_
- [x] 8.2 添加加载进度显示
- 显示已加载/总数
- 加载完成后隐藏进度条
- _Requirements: 5.1, 5.2, 5.3_
- [x] 8.3 编写文件夹切换属性测试
- **Property 3: Request cancellation on folder switch**
- **Property 5: Debounce rapid folder clicks**
- **Validates: Requirements 2.2, 3.2**
- [x] 9. 重构 ImageWaterfall 组件 - 滚动加载
- [x] 9.1 添加滚动加载触发
- 监听滚动事件,接近底部时触发加载下一批
- 集成 ImageLoadService
- _Requirements: 2.3_
- [x] 9.2 优化大数据量渲染
- 确保虚拟滚动正确处理增量数据
- 优化 Worker 数据传输
- _Requirements: 3.1_
- [x] 10. Store 状态扩展
- [x] 10.1 添加加载状态字段
- 添加 `isLoadingImages`、`loadedImageCount`、`hasMoreImages` 等字段
- 添加 `currentLoadContext` 跟踪当前加载上下文
- _Requirements: 4.3, 5.1_
- [x] 10.2 编写状态管理属性测试
- **Property 9: Only latest request result applied**
- **Validates: Requirements 4.3**
- [x] 11. Checkpoint - 确保核心功能测试通过
- Ensure all tests pass, ask the user if questions arise.
- [x] 12. 缓存生命周期管理
- [x] 12.1 实现缓存自动保存
- 图片加载完成后自动保存缓存
- 增量更新缓存(新增/删除图片时)
- _Requirements: 6.1, 6.5_
- [x] 12.2 实现 LRU 缓存驱逐
- 跟踪文件夹缓存访问时间
- 超过阈值时驱逐最久未使用的缓存
- _Requirements: 7.4_
- [ ]* 12.3 编写 LRU 驱逐属性测试
- **Property 18: LRU cache eviction**
- **Validates: Requirements 7.4**
- [x] 13. 组件卸载清理
- [x] 13.1 添加组件卸载时的请求取消
- 在 MainContent、ImageWaterfall 的 useEffect cleanup 中取消请求
- _Requirements: 4.4_
- [ ]* 13.2 编写卸载清理属性测试
- **Property 10: Unmount cancels all requests**
- **Validates: Requirements 4.4**
- [x] 14. 空闲加载与用户操作协调
- [x] 14.1 实现空闲加载暂停机制
- 用户操作时暂停空闲加载
- 操作完成后恢复空闲加载
- _Requirements: 3.3_
- [ ]* 14.2 编写空闲加载协调属性测试
- **Property 6: Background loading pauses on user action**
- **Validates: Requirements 3.3**
- [x] 15. Final Checkpoint - 确保所有测试通过
- Ensure all tests pass, ask the user if questions arise.
+133 -14
View File
@@ -83,6 +83,52 @@ class LibraryDatabase {
-- 复合索引:优化文件夹+时间排序查询
CREATE INDEX IF NOT EXISTS idx_folder_created ON images(folder, created_at DESC);
`);
// Metadata table for tracking database modifications
this.db.exec(`
CREATE TABLE IF NOT EXISTS metadata (
key TEXT PRIMARY KEY,
value TEXT,
updated_at INTEGER
)
`);
// Initialize last_modified if not exists
const lastModified = this.db.prepare('SELECT value FROM metadata WHERE key = ?').get('last_modified');
if (!lastModified) {
this.db.prepare('INSERT INTO metadata (key, value, updated_at) VALUES (?, ?, ?)').run('last_modified', Date.now().toString(), Date.now());
}
}
/**
* 更新数据库最后修改时间
*/
updateLastModified() {
const now = Date.now();
this.db.prepare('INSERT OR REPLACE INTO metadata (key, value, updated_at) VALUES (?, ?, ?)').run('last_modified', now.toString(), now);
return now;
}
/**
* 获取数据库最后修改时间
*/
getLastModified() {
const row = this.db.prepare('SELECT value FROM metadata WHERE key = ?').get('last_modified');
return row ? parseInt(row.value, 10) : Date.now();
}
/**
* 获取缓存元数据
*/
getCacheMeta() {
const lastModified = this.getLastModified();
const imageCount = this.db.prepare('SELECT COUNT(*) as count FROM images').get();
const folderCount = this.db.prepare('SELECT COUNT(*) as count FROM folders').get();
return {
dbModifiedAt: lastModified,
totalImages: imageCount.count,
totalFolders: folderCount.count
};
}
// Image operations
@@ -92,7 +138,7 @@ class LibraryDatabase {
(path, filename, folder, size, width, height, format, file_type, created_at, modified_at, file_hash, thumbnail_path, thumbnail_size, indexed_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`);
return stmt.run(
const result = stmt.run(
imageData.path,
imageData.filename,
imageData.folder,
@@ -108,6 +154,9 @@ class LibraryDatabase {
imageData.thumbnail_size,
Date.now()
);
// 更新数据库修改时间
this.updateLastModified();
return result;
}
getImageByPath(imagePath) {
@@ -120,61 +169,126 @@ class LibraryDatabase {
return stmt.all();
}
searchImages(keywords, filters = {}) {
let query = 'SELECT * FROM images WHERE 1=1';
searchImages(keywords, filters = {}, pagination = null) {
let baseQuery = 'FROM images WHERE 1=1';
const params = [];
// Keyword search (AND logic)
if (keywords && keywords.trim()) {
const terms = keywords.trim().split(/\s+/);
terms.forEach(term => {
query += ' AND filename LIKE ?';
baseQuery += ' AND filename LIKE ?';
params.push(`%${term}%`);
});
}
// Folder filter
if (filters.folder) {
query += ' AND folder LIKE ?';
params.push(`${filters.folder}%`);
// 使用 OR 组合精确匹配和前缀匹配,包含子文件夹
baseQuery += ' AND (folder = ? OR folder LIKE ?)';
params.push(filters.folder, `${filters.folder}/%`);
}
// Format filter
if (filters.formats && filters.formats.length > 0) {
const placeholders = filters.formats.map(() => '?').join(',');
query += ` AND format IN (${placeholders})`;
baseQuery += ` AND format IN (${placeholders})`;
params.push(...filters.formats);
}
// Size filter (in KB)
if (filters.minSize) {
query += ' AND size >= ?';
baseQuery += ' AND size >= ?';
params.push(filters.minSize * 1024);
}
if (filters.maxSize) {
query += ' AND size <= ?';
baseQuery += ' AND size <= ?';
params.push(filters.maxSize * 1024);
}
// Date filter
if (filters.startDate) {
query += ' AND created_at >= ?';
baseQuery += ' AND created_at >= ?';
params.push(filters.startDate);
}
if (filters.endDate) {
query += ' AND created_at <= ?';
baseQuery += ' AND created_at <= ?';
params.push(filters.endDate);
}
query += ' ORDER BY created_at DESC';
// 如果需要分页
if (pagination && typeof pagination.offset === 'number' && typeof pagination.limit === 'number') {
const timings = {};
// 先获取数据(快速)
const query = `SELECT * ${baseQuery} ORDER BY created_at DESC LIMIT ? OFFSET ?`;
const paginatedParams = [...params, pagination.limit, pagination.offset];
let queryStart = Date.now();
const stmt = this.db.prepare(query);
const images = stmt.all(...paginatedParams);
timings.dataQuery = Date.now() - queryStart;
// 如果是第一页且结果数量小于 limit,说明没有更多数据,无需 COUNT
if (pagination.offset === 0 && images.length < pagination.limit) {
return {
images,
total: images.length,
offset: pagination.offset,
limit: pagination.limit,
hasMore: false
};
}
// 如果是文件夹查询,尝试从 folders 表获取 count(更快)
let total = 0;
queryStart = Date.now();
if (filters.folder && !keywords && !filters.formats?.length && !filters.minSize && !filters.maxSize && !filters.startDate && !filters.endDate) {
const folderRow = this.db.prepare('SELECT image_count FROM folders WHERE path = ?').get(filters.folder);
if (folderRow) {
total = folderRow.image_count;
timings.countSource = 'folders_table';
}
}
// 如果无法从 folders 表获取,才执行 COUNT(较慢)
if (total === 0) {
const countStmt = this.db.prepare(`SELECT COUNT(*) as total ${baseQuery}`);
const countResult = countStmt.get(...params);
total = countResult.total;
timings.countSource = 'count_query';
}
timings.countQuery = Date.now() - queryStart;
// 性能日志
const totalTime = timings.dataQuery + timings.countQuery;
if (totalTime > 50) {
console.log(`[DB] searchImages: data=${timings.dataQuery}ms, count=${timings.countQuery}ms (${timings.countSource}), folder=${filters.folder || 'all'}`);
}
return {
images,
total,
offset: pagination.offset,
limit: pagination.limit,
hasMore: pagination.offset + images.length < total
};
}
// 无分页,返回所有结果(保持向后兼容)
const query = `SELECT * ${baseQuery} ORDER BY created_at DESC`;
const stmt = this.db.prepare(query);
return stmt.all(...params);
}
deleteImage(imagePath) {
const stmt = this.db.prepare('DELETE FROM images WHERE path = ?');
return stmt.run(imagePath);
const result = stmt.run(imagePath);
// 更新数据库修改时间
if (result.changes > 0) {
this.updateLastModified();
}
return result;
}
// Update folder field for a specific image (by path)
@@ -216,7 +330,12 @@ class LibraryDatabase {
deleteImagesByFolderPrefix(folderPath) {
// 使用 folderPath/% 确保只匹配真正的子文件夹,避免误删同名前缀文件夹
const stmt = this.db.prepare('DELETE FROM images WHERE folder = ? OR folder LIKE ?');
return stmt.run(folderPath, `${folderPath}/%`);
const result = stmt.run(folderPath, `${folderPath}/%`);
// 更新数据库修改时间
if (result.changes > 0) {
this.updateLastModified();
}
return result;
}
deleteFoldersByPrefix(folderPath) {
+193
View File
@@ -0,0 +1,193 @@
/**
* 缓存 API 路由
* 管理素材库和文件夹的缓存数据
*/
const express = require('express');
const router = express.Router();
const CacheManager = require('../utils/cacheManager');
const dbPool = require('../database/dbPool');
const { getLibrary } = require('../utils/config');
/**
* 获取素材库缓存
* GET /api/cache/library/:libraryId
*/
router.get('/library/:libraryId', (req, res) => {
try {
const { libraryId } = req.params;
const library = getLibrary(libraryId);
if (!library) {
return res.status(404).json({ error: 'Library not found' });
}
const cacheManager = new CacheManager(library.path);
const cache = cacheManager.readLibraryCache();
if (!cache) {
return res.status(404).json({ error: 'Cache not found' });
}
res.json(cache);
} catch (error) {
res.status(500).json({ error: error.message });
}
});
/**
* 保存素材库缓存
* POST /api/cache/library/:libraryId
*/
router.post('/library/:libraryId', (req, res) => {
try {
const { libraryId } = req.params;
const { folderTree, totalCount, dbModifiedAt } = req.body;
const library = getLibrary(libraryId);
if (!library) {
return res.status(404).json({ error: 'Library not found' });
}
const cacheManager = new CacheManager(library.path);
const success = cacheManager.writeLibraryCache({
folderTree,
totalCount,
dbModifiedAt
});
if (success) {
res.json({ success: true });
} else {
res.status(500).json({ error: 'Failed to write cache' });
}
} catch (error) {
res.status(500).json({ error: error.message });
}
});
/**
* 获取文件夹缓存
* GET /api/cache/folder/:libraryId
* Query: folder (可选,不传则获取全部图片缓存)
*/
router.get('/folder/:libraryId', (req, res) => {
try {
const { libraryId } = req.params;
const { folder } = req.query;
const library = getLibrary(libraryId);
if (!library) {
return res.status(404).json({ error: 'Library not found' });
}
const cacheManager = new CacheManager(library.path);
const cache = cacheManager.readFolderCache(folder || null);
if (!cache) {
return res.status(404).json({ error: 'Folder cache not found' });
}
// 验证缓存是否过期
const db = dbPool.acquire(library.path);
try {
const dbModifiedAt = db.getLastModified();
if (cache.dbModifiedAt < dbModifiedAt) {
// 缓存过期
return res.status(410).json({
error: 'Cache stale',
cacheModifiedAt: cache.dbModifiedAt,
dbModifiedAt
});
}
res.json(cache);
} finally {
dbPool.release(library.path);
}
} catch (error) {
res.status(500).json({ error: error.message });
}
});
/**
* 保存文件夹缓存
* POST /api/cache/folder/:libraryId
*/
router.post('/folder/:libraryId', (req, res) => {
try {
const { libraryId } = req.params;
const { folder, images } = req.body;
const library = getLibrary(libraryId);
if (!library) {
return res.status(404).json({ error: 'Library not found' });
}
// 获取当前数据库修改时间
const db = dbPool.acquire(library.path);
let dbModifiedAt;
try {
dbModifiedAt = db.getLastModified();
} finally {
dbPool.release(library.path);
}
const cacheManager = new CacheManager(library.path);
const success = cacheManager.writeFolderCache(folder || null, images, dbModifiedAt);
if (success) {
res.json({ success: true, dbModifiedAt });
} else {
res.status(500).json({ error: 'Failed to write cache' });
}
} catch (error) {
res.status(500).json({ error: error.message });
}
});
/**
* 删除素材库所有缓存
* DELETE /api/cache/library/:libraryId
*/
router.delete('/library/:libraryId', (req, res) => {
try {
const { libraryId } = req.params;
const library = getLibrary(libraryId);
if (!library) {
return res.status(404).json({ error: 'Library not found' });
}
const cacheManager = new CacheManager(library.path);
cacheManager.clearAllCache();
res.json({ success: true });
} catch (error) {
res.status(500).json({ error: error.message });
}
});
/**
* 获取缓存统计信息
* GET /api/cache/stats/:libraryId
*/
router.get('/stats/:libraryId', (req, res) => {
try {
const { libraryId } = req.params;
const library = getLibrary(libraryId);
if (!library) {
return res.status(404).json({ error: 'Library not found' });
}
const cacheManager = new CacheManager(library.path);
const stats = cacheManager.getCacheStats();
res.json(stats);
} catch (error) {
res.status(500).json({ error: error.message });
}
});
module.exports = router;
+88 -6
View File
@@ -7,10 +7,20 @@ const dbPool = require('../database/dbPool');
const { generateThumbnail } = require('../utils/thumbnail');
const { getLibrary } = require('../utils/config');
// Get images with search and filters
// 请求计数器(用于调试)
let requestCounter = 0;
let lastRequestTime = 0;
// Get images with search and filters (supports pagination)
router.get('/', (req, res) => {
const requestId = ++requestCounter;
const startTime = Date.now();
const timeSinceLastRequest = lastRequestTime ? startTime - lastRequestTime : 0;
lastRequestTime = startTime;
console.log(`[Image API #${requestId}] START folder=${req.query.folder || 'all'} offset=${req.query.offset || 0} | gap=${timeSinceLastRequest}ms`);
try {
const { libraryId, keywords, folder, formats, minSize, maxSize, startDate, endDate } = req.query;
const { libraryId, keywords, folder, formats, minSize, maxSize, startDate, endDate, offset, limit } = req.query;
if (!libraryId) {
return res.status(400).json({ error: 'Library ID is required' });
@@ -21,8 +31,10 @@ router.get('/', (req, res) => {
return res.status(404).json({ error: 'Library not found' });
}
const acquireStart = Date.now();
// 使用连接池获取数据库连接
const db = dbPool.acquire(library.path);
const acquireTime = Date.now() - acquireStart;
try {
const filters = {};
@@ -33,9 +45,36 @@ router.get('/', (req, res) => {
if (startDate) filters.startDate = parseInt(startDate);
if (endDate) filters.endDate = parseInt(endDate);
const images = db.searchImages(keywords || '', filters);
// 分页参数(可选)
let pagination = null;
if (offset !== undefined && limit !== undefined) {
pagination = {
offset: parseInt(offset, 10),
limit: parseInt(limit, 10)
};
}
res.json({ images });
const queryStart = Date.now();
const result = db.searchImages(keywords || '', filters, pagination);
const queryTime = Date.now() - queryStart;
const totalTime = Date.now() - startTime;
// 性能日志
console.log(`[Image API #${requestId}] END folder=${folder || 'all'} | acquire=${acquireTime}ms | query=${queryTime}ms | total=${totalTime}ms | count=${pagination ? result.images.length : result.length}`);
// 如果使用分页,返回分页格式;否则保持向后兼容
if (pagination) {
res.json({
images: result.images,
total: result.total,
offset: result.offset,
limit: result.limit,
hasMore: result.hasMore
});
} else {
res.json({ images: result });
}
} finally {
// 释放连接
dbPool.release(library.path);
@@ -45,8 +84,8 @@ router.get('/', (req, res) => {
}
});
// Get total image count
router.get('/count', (req, res) => {
// Get cache metadata (database modification time, counts)
router.get('/cache-meta', (req, res) => {
try {
const { libraryId } = req.query;
@@ -61,7 +100,42 @@ router.get('/count', (req, res) => {
const db = dbPool.acquire(library.path);
try {
const meta = db.getCacheMeta();
res.json(meta);
} finally {
dbPool.release(library.path);
}
} catch (error) {
res.status(500).json({ error: error.message });
}
});
// Get total image count
router.get('/count', (req, res) => {
const startTime = Date.now();
console.log(`[Image API] /count START`);
try {
const { libraryId } = req.query;
if (!libraryId) {
return res.status(400).json({ error: 'Library ID is required' });
}
const library = getLibrary(libraryId);
if (!library) {
return res.status(404).json({ error: 'Library not found' });
}
const acquireStart = Date.now();
const db = dbPool.acquire(library.path);
const acquireTime = Date.now() - acquireStart;
try {
const queryStart = Date.now();
const row = db.db.prepare('SELECT COUNT(*) as count FROM images').get();
const queryTime = Date.now() - queryStart;
const duration = Date.now() - startTime;
console.log(`[Image API] /count END | acquire=${acquireTime}ms | query=${queryTime}ms | total=${duration}ms | count=${row.count}`);
res.json({ count: row.count });
} finally {
dbPool.release(library.path);
@@ -73,6 +147,8 @@ router.get('/count', (req, res) => {
// Get folders
router.get('/folders', (req, res) => {
const startTime = Date.now();
console.log(`[Image API] /folders START`);
try {
const { libraryId } = req.query;
@@ -86,10 +162,16 @@ router.get('/folders', (req, res) => {
}
// 使用连接池
const acquireStart = Date.now();
const db = dbPool.acquire(library.path);
const acquireTime = Date.now() - acquireStart;
try {
const queryStart = Date.now();
const folders = db.getFolderTree();
const queryTime = Date.now() - queryStart;
const duration = Date.now() - startTime;
console.log(`[Image API] /folders END | acquire=${acquireTime}ms | query=${queryTime}ms | total=${duration}ms | count=${folders.length}`);
res.json({ folders });
} finally {
dbPool.release(library.path);
+13
View File
@@ -178,6 +178,19 @@ router.post('/:id/set-current', async (req, res) => {
const newLibrary = config.libraries.find(lib => lib.id === id);
console.log(`[Switch] Switched to library: ${newLibrary?.name}`);
// 预热新数据库连接(避免第一个查询时才创建连接)
if (newLibrary) {
const db = dbPool.acquire(newLibrary.path);
// 执行一个简单查询来预热缓存
try {
db.db.prepare('SELECT 1').get();
console.log(`[Switch] Database connection warmed up`);
} catch (e) {
// 忽略预热错误
}
dbPool.release(newLibrary.path);
}
res.json({ message: 'Current library set successfully' });
} catch (error) {
res.status(500).json({ error: error.message });
+17 -18
View File
@@ -3,29 +3,28 @@ const router = express.Router();
// Start watching a library
router.post('/start/:libraryId', (req, res) => {
const startTime = Date.now();
try {
const { libraryId } = req.params;
const fileWatcher = req.app.get('fileWatcher');
const io = req.app.get('io');
// 尝试启动监控,如果失败则返回详细错误
try {
fileWatcher.watch(libraryId, io);
res.json({
message: 'File watching started',
libraryId,
isWatching: true
});
} catch (watchError) {
// 监控启动失败,但不应该导致整个请求失败
console.error(`Failed to start file watching for ${libraryId}:`, watchError.message);
res.status(200).json({
message: 'File watching could not be started',
libraryId,
isWatching: false,
error: watchError.message
});
}
// 立即返回响应,让文件监控在后台启动
res.json({
message: 'File watching starting',
libraryId,
isWatching: true
});
// 异步启动监控(不阻塞响应)
setImmediate(() => {
try {
fileWatcher.watch(libraryId, io);
console.log(`[Watch] Started in ${Date.now() - startTime}ms`);
} catch (watchError) {
console.error(`Failed to start file watching for ${libraryId}:`, watchError.message);
}
});
} catch (error) {
res.status(500).json({ error: error.message });
}
+2
View File
@@ -49,11 +49,13 @@ const libraryRouter = require('./routes/library');
const imageRouter = require('./routes/image');
const scanRouter = require('./routes/scan');
const watchRouter = require('./routes/watch');
const cacheRouter = require('./routes/cache');
app.use('/api/library', libraryRouter);
app.use('/api/image', imageRouter);
app.use('/api/scan', scanRouter);
app.use('/api/watch', watchRouter);
app.use('/api/cache', cacheRouter);
// Serve static files (production)
if (FRONTEND_DIST) {
+267
View File
@@ -0,0 +1,267 @@
/**
* CacheManager - 后端缓存文件管理
* 管理 .flypic/cache/ 目录下的缓存文件
*/
const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
// 缓存版本号
const CACHE_VERSION = 1;
class CacheManager {
constructor(libraryPath) {
this.libraryPath = libraryPath;
this.cacheDir = path.join(libraryPath, '.flypic', 'cache');
this.foldersDir = path.join(this.cacheDir, 'folders');
// 确保缓存目录存在
this.ensureDirs();
}
/**
* 确保缓存目录存在
*/
ensureDirs() {
if (!fs.existsSync(this.cacheDir)) {
fs.mkdirSync(this.cacheDir, { recursive: true });
}
if (!fs.existsSync(this.foldersDir)) {
fs.mkdirSync(this.foldersDir, { recursive: true });
}
}
/**
* 生成文件夹路径的哈希值(用于缓存文件名)
*/
hashFolder(folderPath) {
return crypto.createHash('md5').update(folderPath || '__all__').digest('hex');
}
// ==================== 素材库缓存 ====================
/**
* 获取素材库缓存文件路径
*/
getLibraryCachePath() {
return path.join(this.cacheDir, 'library.json');
}
/**
* 读取素材库缓存
* @returns {object|null}
*/
readLibraryCache() {
try {
const cachePath = this.getLibraryCachePath();
if (!fs.existsSync(cachePath)) {
return null;
}
const content = fs.readFileSync(cachePath, 'utf-8');
const cache = JSON.parse(content);
// 验证版本
if (cache.version !== CACHE_VERSION) {
return null;
}
return cache;
} catch (error) {
console.warn('Failed to read library cache:', error.message);
return null;
}
}
/**
* 写入素材库缓存
* @param {object} data - { folderTree, totalCount, dbModifiedAt }
*/
writeLibraryCache(data) {
try {
const cachePath = this.getLibraryCachePath();
const cache = {
version: CACHE_VERSION,
createdAt: Date.now(),
dbModifiedAt: data.dbModifiedAt,
totalCount: data.totalCount,
folderTree: data.folderTree
};
fs.writeFileSync(cachePath, JSON.stringify(cache), 'utf-8');
return true;
} catch (error) {
console.warn('Failed to write library cache:', error.message);
return false;
}
}
// ==================== 文件夹缓存 ====================
/**
* 获取文件夹缓存文件路径
*/
getFolderCachePath(folderPath) {
const hash = this.hashFolder(folderPath);
return path.join(this.foldersDir, `${hash}.json`);
}
/**
* 读取文件夹缓存
* @param {string|null} folderPath
* @returns {object|null}
*/
readFolderCache(folderPath) {
try {
const cachePath = this.getFolderCachePath(folderPath);
if (!fs.existsSync(cachePath)) {
return null;
}
const content = fs.readFileSync(cachePath, 'utf-8');
const cache = JSON.parse(content);
// 验证版本
if (cache.version !== CACHE_VERSION) {
return null;
}
return cache;
} catch (error) {
console.warn('Failed to read folder cache:', error.message);
return null;
}
}
/**
* 写入文件夹缓存
* @param {string|null} folderPath
* @param {Array} images
* @param {number} dbModifiedAt
*/
writeFolderCache(folderPath, images, dbModifiedAt) {
try {
const cachePath = this.getFolderCachePath(folderPath);
// 精简图片数据
const slimImages = images.map(img => ({
id: img.id,
path: img.path,
filename: img.filename,
width: img.width,
height: img.height,
thumbnail_path: img.thumbnail_path,
file_type: img.file_type,
created_at: img.created_at,
format: img.format
}));
const cache = {
version: CACHE_VERSION,
folder: folderPath || '__all__',
cachedAt: Date.now(),
dbModifiedAt,
imageCount: images.length,
images: slimImages
};
fs.writeFileSync(cachePath, JSON.stringify(cache), 'utf-8');
return true;
} catch (error) {
console.warn('Failed to write folder cache:', error.message);
return false;
}
}
// ==================== 缓存清理 ====================
/**
* 删除素材库缓存
*/
deleteLibraryCache() {
try {
const cachePath = this.getLibraryCachePath();
if (fs.existsSync(cachePath)) {
fs.unlinkSync(cachePath);
}
return true;
} catch (error) {
console.warn('Failed to delete library cache:', error.message);
return false;
}
}
/**
* 删除文件夹缓存
*/
deleteFolderCache(folderPath) {
try {
const cachePath = this.getFolderCachePath(folderPath);
if (fs.existsSync(cachePath)) {
fs.unlinkSync(cachePath);
}
return true;
} catch (error) {
console.warn('Failed to delete folder cache:', error.message);
return false;
}
}
/**
* 清除所有缓存
*/
clearAllCache() {
try {
// 删除素材库缓存
this.deleteLibraryCache();
// 删除所有文件夹缓存
if (fs.existsSync(this.foldersDir)) {
const files = fs.readdirSync(this.foldersDir);
for (const file of files) {
fs.unlinkSync(path.join(this.foldersDir, file));
}
}
return true;
} catch (error) {
console.warn('Failed to clear all cache:', error.message);
return false;
}
}
/**
* 获取缓存统计信息
*/
getCacheStats() {
try {
const stats = {
hasLibraryCache: fs.existsSync(this.getLibraryCachePath()),
folderCacheCount: 0,
totalSize: 0
};
if (fs.existsSync(this.foldersDir)) {
const files = fs.readdirSync(this.foldersDir);
stats.folderCacheCount = files.length;
for (const file of files) {
const filePath = path.join(this.foldersDir, file);
const fileStat = fs.statSync(filePath);
stats.totalSize += fileStat.size;
}
}
if (stats.hasLibraryCache) {
const libCacheStat = fs.statSync(this.getLibraryCachePath());
stats.totalSize += libCacheStat.size;
}
return stats;
} catch (error) {
return { hasLibraryCache: false, folderCacheCount: 0, totalSize: 0 };
}
}
}
module.exports = CacheManager;
+201
View File
@@ -0,0 +1,201 @@
/**
* CacheManager 属性测试
* **Feature: library-switch-optimization, Property 12: Cache file creation after full load**
* **Feature: library-switch-optimization, Property 16: Folder cache creation**
* **Validates: Requirements 6.1, 7.1**
*/
const { describe, it, expect, beforeEach, afterEach } = require('vitest');
const fc = require('fast-check');
const fs = require('fs');
const path = require('path');
const os = require('os');
const CacheManager = require('./cacheManager');
describe('CacheManager', () => {
let testDir;
let cacheManager;
beforeEach(() => {
// 创建临时测试目录
testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'flypic-test-'));
cacheManager = new CacheManager(testDir);
});
afterEach(() => {
// 清理测试目录
fs.rmSync(testDir, { recursive: true, force: true });
});
/**
* **Property 12: Cache file creation after full load**
* *For any* library that completes full image loading, a cache file should
* exist in the .flypic/cache directory.
*/
describe('Property 12: Cache file creation after full load', () => {
it('should create library cache file when writeLibraryCache is called', () => {
fc.assert(
fc.property(
fc.integer({ min: 0, max: 100000 }),
fc.integer({ min: 0, max: Date.now() }),
(totalCount, dbModifiedAt) => {
const data = {
folderTree: [],
totalCount,
dbModifiedAt
};
cacheManager.writeLibraryCache(data);
const cachePath = cacheManager.getLibraryCachePath();
return fs.existsSync(cachePath);
}
),
{ numRuns: 50 }
);
});
it('should persist library cache data correctly', () => {
fc.assert(
fc.property(
fc.integer({ min: 0, max: 100000 }),
fc.integer({ min: 0, max: Date.now() }),
(totalCount, dbModifiedAt) => {
const data = {
folderTree: [{ path: 'test', name: 'test', children: [] }],
totalCount,
dbModifiedAt
};
cacheManager.writeLibraryCache(data);
const cache = cacheManager.readLibraryCache();
return cache !== null &&
cache.totalCount === totalCount &&
cache.dbModifiedAt === dbModifiedAt &&
cache.folderTree.length === 1;
}
),
{ numRuns: 50 }
);
});
});
/**
* **Property 16: Folder cache creation**
* *For any* folder whose images are fully loaded, a separate cache file
* should be created for that folder.
*/
describe('Property 16: Folder cache creation', () => {
it('should create folder cache file when writeFolderCache is called', () => {
fc.assert(
fc.property(
fc.string({ minLength: 1, maxLength: 50 }),
fc.integer({ min: 0, max: Date.now() }),
(folderPath, dbModifiedAt) => {
const images = [
{ id: 1, path: 'img1.jpg', filename: 'img1.jpg', width: 100, height: 100 }
];
cacheManager.writeFolderCache(folderPath, images, dbModifiedAt);
const cachePath = cacheManager.getFolderCachePath(folderPath);
return fs.existsSync(cachePath);
}
),
{ numRuns: 50 }
);
});
it('should create separate cache files for different folders', () => {
fc.assert(
fc.property(
fc.array(fc.string({ minLength: 1, maxLength: 20 }), { minLength: 2, maxLength: 10 }),
(folders) => {
const uniqueFolders = [...new Set(folders)];
const dbModifiedAt = Date.now();
const images = [{ id: 1, path: 'img.jpg', filename: 'img.jpg', width: 100, height: 100 }];
for (const folder of uniqueFolders) {
cacheManager.writeFolderCache(folder, images, dbModifiedAt);
}
// 每个文件夹应该有独立的缓存文件
const cacheFiles = new Set();
for (const folder of uniqueFolders) {
const cachePath = cacheManager.getFolderCachePath(folder);
if (fs.existsSync(cachePath)) {
cacheFiles.add(cachePath);
}
}
return cacheFiles.size === uniqueFolders.length;
}
),
{ numRuns: 50 }
);
});
it('should persist folder cache data correctly', () => {
fc.assert(
fc.property(
fc.string({ minLength: 1, maxLength: 50 }),
fc.integer({ min: 1, max: 100 }),
fc.integer({ min: 0, max: Date.now() }),
(folderPath, imageCount, dbModifiedAt) => {
const images = Array.from({ length: imageCount }, (_, i) => ({
id: i + 1,
path: `img${i}.jpg`,
filename: `img${i}.jpg`,
width: 100,
height: 100,
thumbnail_path: `thumb${i}.webp`,
file_type: 'image',
created_at: Date.now(),
format: 'jpg'
}));
cacheManager.writeFolderCache(folderPath, images, dbModifiedAt);
const cache = cacheManager.readFolderCache(folderPath);
return cache !== null &&
cache.imageCount === imageCount &&
cache.images.length === imageCount &&
cache.dbModifiedAt === dbModifiedAt;
}
),
{ numRuns: 50 }
);
});
});
describe('Cache deletion', () => {
it('should delete library cache', () => {
cacheManager.writeLibraryCache({ folderTree: [], totalCount: 100, dbModifiedAt: Date.now() });
expect(fs.existsSync(cacheManager.getLibraryCachePath())).toBe(true);
cacheManager.deleteLibraryCache();
expect(fs.existsSync(cacheManager.getLibraryCachePath())).toBe(false);
});
it('should delete folder cache', () => {
const folder = 'test-folder';
cacheManager.writeFolderCache(folder, [], Date.now());
expect(fs.existsSync(cacheManager.getFolderCachePath(folder))).toBe(true);
cacheManager.deleteFolderCache(folder);
expect(fs.existsSync(cacheManager.getFolderCachePath(folder))).toBe(false);
});
it('should clear all cache', () => {
cacheManager.writeLibraryCache({ folderTree: [], totalCount: 100, dbModifiedAt: Date.now() });
cacheManager.writeFolderCache('folder1', [], Date.now());
cacheManager.writeFolderCache('folder2', [], Date.now());
cacheManager.clearAllCache();
expect(fs.existsSync(cacheManager.getLibraryCachePath())).toBe(false);
expect(fs.existsSync(cacheManager.getFolderCachePath('folder1'))).toBe(false);
expect(fs.existsSync(cacheManager.getFolderCachePath('folder2'))).toBe(false);
});
});
});
+134 -118
View File
@@ -1,14 +1,15 @@
const chokidar = require('chokidar');
const { Worker } = require('worker_threads');
const path = require('path');
const { getLibrary } = require('./config');
const { syncLibrary, applyChangesFromEvents } = require('./scanner');
const { applyChangesFromEvents } = require('./scanner');
const dbPool = require('../database/dbPool');
class FileWatcher {
constructor() {
this.watchers = new Map(); // libraryId -> watcher
this.workers = new Map(); // libraryId -> Worker
this.debounceTimers = new Map(); // libraryId -> { timer, forceRebuildFolders }
this.changeBuffers = new Map(); // libraryId -> { filesAdded, filesChanged, filesRemoved, dirsAdded, dirsRemoved }
this.ioRef = null; // Socket.IO 引用
}
// 获取或创建变更缓冲区
@@ -36,10 +37,13 @@ class FileWatcher {
);
}
// 启动监控
// 启动监控(使用 Worker Thread,不阻塞主线程)
watch(libraryId, io) {
// 保存 io 引用
this.ioRef = io;
// 如果已经在监控,先停止
if (this.watchers.has(libraryId)) {
if (this.workers.has(libraryId)) {
this.unwatch(libraryId);
}
@@ -56,137 +60,149 @@ class FileWatcher {
} catch (error) {
const errorMsg = `Cannot access library path: ${library.path} - ${error.message}`;
console.error(errorMsg);
console.error('提示:在飞牛 fnOS 上,请确保在应用设置中授予了文件夹访问权限');
throw new Error(errorMsg);
}
console.log(`Starting file watcher for library: ${library.name} (${library.path})`);
console.log(`[FileWatcher] Starting worker for: ${library.name} (${library.path})`);
// 监控所有文件(使用通配符)
const pattern = '**/*.*';
// 创建监控器(监控所有文件和文件夹)
const watcher = chokidar.watch([pattern, '**/'], {
cwd: library.path,
ignored: [
'**/node_modules/**',
'**/.git/**',
'**/.flypic/**', // 忽略自己的缓存目录
'**/.*' // 忽略隐藏文件
],
persistent: true,
ignoreInitial: true, // 忽略初始扫描
usePolling: false, // 不使用轮询,减少 CPU 占用
awaitWriteFinish: {
stabilityThreshold: 1000, // 文件稳定 1 秒后触发,确保复制完成
pollInterval: 200
// 创建 Worker Thread
const workerPath = path.join(__dirname, 'fileWatcherWorker.js');
const worker = new Worker(workerPath, {
workerData: {
libraryPath: library.path,
libraryName: library.name
}
});
// 防抖处理:多个文件变化合并为一次同步(自适应时长)
const debouncedSync = (forceRebuildFolders = false) => {
const buf = this._getBuffer(libraryId);
const changeCount = this._bufferCount(buf);
// 处理 Worker 消息
worker.on('message', (msg) => {
this._handleWorkerMessage(libraryId, library, msg);
});
// 清除之前的定时器
if (this.debounceTimers.has(libraryId)) {
const oldTimer = this.debounceTimers.get(libraryId);
clearTimeout(oldTimer.timer);
// 聚合 forceRebuildFolders 标记
forceRebuildFolders = forceRebuildFolders || oldTimer.forceRebuildFolders;
worker.on('error', (error) => {
console.error(`[FileWatcher] Worker error for ${library.name}:`, error);
});
worker.on('exit', (code) => {
if (code !== 0) {
console.error(`[FileWatcher] Worker exited with code ${code} for ${library.name}`);
}
this.workers.delete(libraryId);
});
// 自适应防抖时间:更快响应
let debounceMs = 2000;
if (changeCount <= 1) debounceMs = 800; // 单文件 0.8 秒
else if (changeCount <= 5) debounceMs = 1000; // 少量 1 秒
else if (changeCount <= 20) debounceMs = 1500;
else if (changeCount <= 100) debounceMs = 2000;
else debounceMs = 3000; // 大批量 3 秒
this.workers.set(libraryId, worker);
}
const timer = setTimeout(async () => {
const snapshot = this._getBuffer(libraryId);
// 清空缓冲区(开始新一轮累计)
this.changeBuffers.set(libraryId, {
filesAdded: new Set(),
filesChanged: new Set(),
filesRemoved: new Set(),
dirsAdded: new Set(),
dirsRemoved: new Set()
});
// 处理 Worker 发来的消息
_handleWorkerMessage(libraryId, library, msg) {
switch (msg.type) {
case 'add':
this._getBuffer(libraryId).filesAdded.add(msg.path);
this._debouncedSync(libraryId, library);
break;
case 'unlink':
this._getBuffer(libraryId).filesRemoved.add(msg.path);
this._debouncedSync(libraryId, library);
break;
case 'change':
this._getBuffer(libraryId).filesChanged.add(msg.path);
this._debouncedSync(libraryId, library);
break;
case 'addDir':
this._getBuffer(libraryId).dirsAdded.add(msg.path);
this._debouncedSync(libraryId, library, true);
break;
case 'unlinkDir':
this._getBuffer(libraryId).dirsRemoved.add(msg.path);
this._debouncedSync(libraryId, library, true);
break;
case 'ready':
console.log(`[FileWatcher] Ready for: ${library.name}`);
break;
case 'error':
console.error(`[FileWatcher] Error for ${library.name}:`, msg.message);
break;
case 'closed':
console.log(`[FileWatcher] Closed for: ${library.name}`);
break;
}
}
// 从连接池获取数据库连接
const db = dbPool.acquire(library.path);
// 防抖同步
_debouncedSync(libraryId, library, forceRebuildFolders = false) {
const buf = this._getBuffer(libraryId);
const changeCount = this._bufferCount(buf);
try {
const total = this._bufferCount(snapshot);
let results;
// 清除之前的定时器
if (this.debounceTimers.has(libraryId)) {
const oldTimer = this.debounceTimers.get(libraryId);
clearTimeout(oldTimer.timer);
forceRebuildFolders = forceRebuildFolders || oldTimer.forceRebuildFolders;
}
// 始终使用基于事件的快速同步(不再调用 syncLibrary)
results = await applyChangesFromEvents(library.path, db, {
filesAdded: Array.from(snapshot.filesAdded),
filesChanged: Array.from(snapshot.filesChanged),
filesRemoved: Array.from(snapshot.filesRemoved),
dirsAdded: Array.from(snapshot.dirsAdded),
dirsRemoved: Array.from(snapshot.dirsRemoved)
});
// 自适应防抖时间
let debounceMs = 2000;
if (changeCount <= 1) debounceMs = 800;
else if (changeCount <= 5) debounceMs = 1000;
else if (changeCount <= 20) debounceMs = 1500;
else if (changeCount <= 100) debounceMs = 2000;
else debounceMs = 3000;
// 通过 Socket.IO 通知前端
io.emit('scanComplete', { libraryId, results });
console.log(`Sync complete for ${library.name}:`, results);
} catch (error) {
console.error(`Sync error for ${library.name}:`, error);
io.emit('scanError', { libraryId, error: error.message });
} finally {
// 释放数据库连接(不关闭,复用)
dbPool.release(library.path);
}
this.debounceTimers.delete(libraryId);
}, debounceMs);
this.debounceTimers.set(libraryId, { timer, forceRebuildFolders });
};
// 监听文件和文件夹变化(写入缓冲,统一合并处理)
watcher
.on('add', (filePath) => {
this._getBuffer(libraryId).filesAdded.add(filePath);
debouncedSync();
})
.on('unlink', (filePath) => {
this._getBuffer(libraryId).filesRemoved.add(filePath);
debouncedSync();
})
.on('change', (filePath) => {
this._getBuffer(libraryId).filesChanged.add(filePath);
debouncedSync();
})
.on('addDir', (dirPath) => {
this._getBuffer(libraryId).dirsAdded.add(dirPath);
debouncedSync(true); // 强制重建文件夹结构
})
.on('unlinkDir', (dirPath) => {
this._getBuffer(libraryId).dirsRemoved.add(dirPath);
debouncedSync(true); // 强制重建文件夹结构
})
.on('error', (error) => {
console.error(`Watcher error for ${library.name}:`, error);
})
.on('ready', () => {
console.log(`File watcher ready for: ${library.name}`);
const timer = setTimeout(async () => {
const snapshot = this._getBuffer(libraryId);
// 清空缓冲区
this.changeBuffers.set(libraryId, {
filesAdded: new Set(),
filesChanged: new Set(),
filesRemoved: new Set(),
dirsAdded: new Set(),
dirsRemoved: new Set()
});
this.watchers.set(libraryId, watcher);
const db = dbPool.acquire(library.path);
try {
const results = await applyChangesFromEvents(library.path, db, {
filesAdded: Array.from(snapshot.filesAdded),
filesChanged: Array.from(snapshot.filesChanged),
filesRemoved: Array.from(snapshot.filesRemoved),
dirsAdded: Array.from(snapshot.dirsAdded),
dirsRemoved: Array.from(snapshot.dirsRemoved)
});
if (this.ioRef) {
this.ioRef.emit('scanComplete', { libraryId, results });
}
console.log(`[FileWatcher] Sync complete for ${library.name}:`, results);
} catch (error) {
console.error(`[FileWatcher] Sync error for ${library.name}:`, error);
if (this.ioRef) {
this.ioRef.emit('scanError', { libraryId, error: error.message });
}
} finally {
dbPool.release(library.path);
}
this.debounceTimers.delete(libraryId);
}, debounceMs);
this.debounceTimers.set(libraryId, { timer, forceRebuildFolders });
}
// 停止监控
unwatch(libraryId) {
const watcher = this.watchers.get(libraryId);
if (watcher) {
watcher.close();
this.watchers.delete(libraryId);
console.log(`Stopped file watcher for library: ${libraryId}`);
const worker = this.workers.get(libraryId);
if (worker) {
// 发送关闭命令给 Worker
worker.postMessage({ type: 'close' });
// 给 Worker 一些时间优雅关闭,然后强制终止
setTimeout(() => {
if (this.workers.has(libraryId)) {
worker.terminate();
this.workers.delete(libraryId);
}
}, 1000);
console.log(`[FileWatcher] Stopping worker for: ${libraryId}`);
}
// 清除防抖定时器
@@ -204,19 +220,19 @@ class FileWatcher {
// 停止所有监控
unwatchAll() {
for (const libraryId of this.watchers.keys()) {
for (const libraryId of this.workers.keys()) {
this.unwatch(libraryId);
}
}
// 获取监控状态
isWatching(libraryId) {
return this.watchers.has(libraryId);
return this.workers.has(libraryId);
}
// 获取所有正在监控的库
getWatchedLibraries() {
return Array.from(this.watchers.keys());
return Array.from(this.workers.keys());
}
}
+64
View File
@@ -0,0 +1,64 @@
/**
* File Watcher Worker - 在独立线程中运行 chokidar
* 避免文件监控初始化阻塞主线程的事件循环
*/
const { parentPort, workerData } = require('worker_threads');
const chokidar = require('chokidar');
const { libraryPath, libraryName } = workerData;
console.log(`[Worker] Starting chokidar for: ${libraryName}`);
// 创建监控器
const watcher = chokidar.watch(['**/*.*', '**/'], {
cwd: libraryPath,
ignored: [
'**/node_modules/**',
'**/.git/**',
'**/.flypic/**',
'**/.*'
],
persistent: true,
ignoreInitial: true,
usePolling: false,
awaitWriteFinish: {
stabilityThreshold: 1000,
pollInterval: 200
}
});
// 监听事件并发送到主线程
watcher
.on('add', (filePath) => {
parentPort.postMessage({ type: 'add', path: filePath });
})
.on('unlink', (filePath) => {
parentPort.postMessage({ type: 'unlink', path: filePath });
})
.on('change', (filePath) => {
parentPort.postMessage({ type: 'change', path: filePath });
})
.on('addDir', (dirPath) => {
parentPort.postMessage({ type: 'addDir', path: dirPath });
})
.on('unlinkDir', (dirPath) => {
parentPort.postMessage({ type: 'unlinkDir', path: dirPath });
})
.on('error', (error) => {
parentPort.postMessage({ type: 'error', message: error.message });
})
.on('ready', () => {
console.log(`[Worker] File watcher ready for: ${libraryName}`);
parentPort.postMessage({ type: 'ready' });
});
// 监听主线程的关闭命令
parentPort.on('message', (msg) => {
if (msg.type === 'close') {
console.log(`[Worker] Closing watcher for: ${libraryName}`);
watcher.close().then(() => {
parentPort.postMessage({ type: 'closed' });
process.exit(0);
});
}
});
+6 -2
View File
@@ -6,7 +6,9 @@
"scripts": {
"dev": "vite",
"build": "vite build",
"preview": "vite preview"
"preview": "vite preview",
"test": "vitest run",
"test:watch": "vitest"
},
"dependencies": {
"axios": "^1.6.2",
@@ -25,8 +27,10 @@
"@types/react-dom": "^18.2.17",
"@vitejs/plugin-react": "^4.2.1",
"autoprefixer": "^10.4.16",
"fast-check": "^3.15.0",
"postcss": "^8.4.32",
"tailwindcss": "^3.4.0",
"vite": "^5.0.8"
"vite": "^5.0.8",
"vitest": "^1.2.0"
}
}
+93 -20
View File
@@ -5,13 +5,14 @@ import { VariableSizeList as List } from 'react-window';
import { Play, FileText, Palette, Music, File } from 'lucide-react';
import useStore from '../store/useStore';
import { imageAPI } from '../services/api';
import imageLoadService from '../services/imageLoadService';
import FileViewer from './FileViewer';
// 虚拟滚动阈值:超过此数量启用虚拟滚动
const VIRTUAL_SCROLL_THRESHOLD = 500;
const VIRTUAL_SCROLL_THRESHOLD = 100;
// Web Worker 阈值:超过此数量使用 Worker 计算布局
const WORKER_THRESHOLD = 200;
const WORKER_THRESHOLD = 500;
function ImageWaterfall() {
const {
@@ -24,7 +25,8 @@ function ImageWaterfall() {
setSelectedImages,
toggleImageSelection,
clearSelection,
isResizingPanels
isResizingPanels,
imageLoadingState
} = useStore();
const containerRef = useRef(null);
const listRef = useRef(null);
@@ -125,25 +127,44 @@ function ImageWaterfall() {
// 是否使用 Worker 计算布局
const useWorker = filteredImages.length > WORKER_THRESHOLD;
// 当图片数据变化时重置 Worker 状态(更可靠的重置方式)
const prevImagesLengthRef = useRef(0);
// 跟踪图片数据变化,用于增量计算判断
const prevImagesRef = useRef({ length: 0, firstId: null, libraryId: null });
const incrementalModeRef = useRef(false);
useEffect(() => {
// 图片列表从有到无或数量大幅变化时重置
const prevLen = prevImagesLengthRef.current;
const prevLen = prevImagesRef.current.length;
const currLen = filteredImages.length;
const prevFirstId = prevImagesRef.current.firstId;
const currFirstId = filteredImages[0]?.id;
const prevLibraryId = prevImagesRef.current.libraryId;
if (prevLen > 0 && currLen === 0) {
// 图片被清空,重置 Worker 状态
setWorkerRows([]);
requestIdRef.current = 0;
} else if (currLen > 0 && Math.abs(currLen - prevLen) > prevLen * 0.5) {
// 数量变化超过50%,可能是切换素材库,重置
// 判断是否需要重置
const shouldReset =
(prevLen > 0 && currLen === 0) || // 图片被清空
(currFirstId !== prevFirstId) || // 第一张图片变了(切换文件夹/素材库)
(currentLibraryId !== prevLibraryId); // 素材库变了
if (shouldReset) {
// 重置 Worker 状态
setWorkerRows([]);
requestIdRef.current = 0;
incrementalModeRef.current = false;
// 通知 Worker 重置缓存
if (workerRef.current) {
workerRef.current.postMessage({ reset: true, requestId: 0 });
}
} else if (currLen > prevLen) {
// 图片数量增加,可以使用增量模式
incrementalModeRef.current = true;
}
prevImagesLengthRef.current = currLen;
}, [filteredImages.length]);
prevImagesRef.current = {
length: currLen,
firstId: currFirstId,
libraryId: currentLibraryId
};
}, [filteredImages, currentLibraryId]);
// 初始化 Web Worker
useEffect(() => {
@@ -180,11 +201,26 @@ function ImageWaterfall() {
}
const requestId = ++requestIdRef.current;
// 只传输必要的字段,减少数据传输开销
// 对于大量图片,这可以显著减少序列化/反序列化时间
const minimalImages = filteredImages.map(img => ({
id: img.id,
width: img.width,
height: img.height,
filename: img.filename,
thumbnail_path: img.thumbnail_path,
path: img.path,
file_type: img.file_type,
format: img.format
}));
workerRef.current.postMessage({
images: filteredImages,
images: minimalImages,
containerWidth,
targetHeight: thumbnailHeight,
requestId
requestId,
incremental: incrementalModeRef.current
});
}, [filteredImages, containerWidth, thumbnailHeight, useWorker]);
@@ -303,10 +339,25 @@ function ImageWaterfall() {
return rows[index][0].calculatedHeight + 28 + 32;
}, [rows, thumbnailHeight]);
// 当行数据变化时,重置虚拟列表缓存
// 跟踪上次的行数,用于增量更新虚拟列表
const prevRowCountRef = useRef(0);
// 当行数据变化时,智能更新虚拟列表缓存
useEffect(() => {
if (listRef.current && useVirtualScroll) {
listRef.current.resetAfterIndex(0);
const prevRowCount = prevRowCountRef.current;
const currRowCount = rows.length;
if (currRowCount > prevRowCount && prevRowCount > 0) {
// 增量更新:只重置新增的行
// 从上一个最后一行开始重置(因为最后一行可能被重新计算)
listRef.current.resetAfterIndex(Math.max(0, prevRowCount - 1));
} else {
// 完全重置
listRef.current.resetAfterIndex(0);
}
prevRowCountRef.current = currRowCount;
}
}, [rows, useVirtualScroll]);
@@ -478,12 +529,34 @@ function ImageWaterfall() {
itemSize={getRowHeight}
className="p-4"
overscanCount={3}
onScroll={({ scrollOffset, scrollDirection }) => {
// 滚动到接近底部时触发加载更多
if (scrollDirection === 'forward' && imageLoadingState.hasMore && !imageLoadingState.isLoading) {
const totalHeight = rows.reduce((sum, _, i) => sum + getRowHeight(i), 0);
const scrollBottom = scrollOffset + (containerHeight || 600);
// 距离底部 500px 时触发加载
if (totalHeight - scrollBottom < 500) {
imageLoadService.loadNextBatch();
}
}
}}
>
{renderRow}
</List>
) : (
/* 普通渲染模式(≤500张图片) */
<div className="h-full overflow-y-auto p-4">
<div
className="h-full overflow-y-auto p-4"
onScroll={(e) => {
// 滚动到接近底部时触发加载更多
if (imageLoadingState.hasMore && !imageLoadingState.isLoading) {
const { scrollTop, scrollHeight, clientHeight } = e.target;
if (scrollHeight - scrollTop - clientHeight < 500) {
imageLoadService.loadNextBatch();
}
}
}}
>
<div className="space-y-8">
{rows.map((row, rowIndex) => {
let flatIndexBase = 0;
+161 -172
View File
@@ -2,6 +2,8 @@ import { useEffect, useRef, useState, useCallback } from 'react';
import { Pause, Play } from 'lucide-react';
import useStore from '../store/useStore';
import { imageAPI, scanAPI } from '../services/api';
import imageLoadService from '../services/imageLoadService';
import requestManager, { RequestType } from '../services/requestManager';
import ImageWaterfall from './ImageWaterfall';
import Dashboard from './Dashboard';
@@ -14,154 +16,177 @@ function MainContent() {
setImages,
setTotalImageCount,
scanProgress,
scanStartTime
scanStartTime,
imageLoadingState
} = useStore();
// 使用 ref 跟踪最新的请求
const loadingRequestRef = useRef(0);
// 使用 ref 跟踪最新的请求上下文
const currentRequestContextRef = useRef(null);
// 文件夹切换防抖
const folderDebounceRef = useRef(null);
const debounceTimerRef = useRef(null);
const [isLoadingImages, setIsLoadingImages] = useState(false);
// 计算预估剩余时间(优先使用后端提供的estimatedTimeLeft)
const getEstimatedTime = () => {
if (!scanProgress || scanProgress.current === 0) {
return null;
}
// 优先使用后端提供的预估时间
if (scanProgress.estimatedTimeLeft !== undefined) {
const seconds = scanProgress.estimatedTimeLeft;
if (seconds < 1) return '即将完成';
if (seconds < 60) return `剩余约 ${seconds} 秒`;
if (seconds < 3600) {
const min = Math.floor(seconds / 60);
const sec = seconds % 60;
return sec > 0 ? `剩余约 ${min} 分 ${sec} 秒` : `剩余约 ${min} 分钟`;
}
const hrs = Math.floor(seconds / 3600);
const min = Math.floor((seconds % 3600) / 60);
return min > 0 ? `剩余约 ${hrs} 小时 ${min} 分钟` : `剩余约 ${hrs} 小时`;
}
// 降级:使用前端计算
if (!scanStartTime) return null;
const elapsed = Date.now() - scanStartTime;
const progress = scanProgress.current / scanProgress.total;
if (progress === 0) return null;
const remaining = (elapsed / progress) - elapsed;
const seconds = Math.ceil(remaining / 1000);
if (seconds < 60) return `剩余约 ${seconds} 秒`;
if (seconds < 3600) {
const min = Math.floor(seconds / 60);
const sec = seconds % 60;
return sec > 0 ? `剩余约 ${min} 分 ${sec} 秒` : `剩余约 ${min} 分钟`;
}
const hrs = Math.floor(seconds / 3600);
const min = Math.floor((seconds % 3600) / 60);
return min > 0 ? `剩余约 ${hrs} 小时 ${min} 分钟` : `剩余约 ${hrs} 小时`;
};
// 使用 ref 追踪上次的 libraryId,避免重复加载
// 使用 ref 追踪上次的 libraryId
const lastLibraryIdRef = useRef(null);
// 扫描控制
const [scanPaused, setScanPaused] = useState(false);
const [isStoppingOrResuming, setIsStoppingOrResuming] = useState(false);
useEffect(() => {
if (currentLibraryId) {
// 文件夹切换使用防抖(30ms),避免快速点击导致多次请求
if (folderDebounceRef.current) {
clearTimeout(folderDebounceRef.current);
}
folderDebounceRef.current = setTimeout(() => {
loadImages();
}, selectedFolder !== null ? 30 : 0); // 选择文件夹时防抖,清空时立即加载
// 只在切换素材库时加载文件夹和总数
if (lastLibraryIdRef.current !== currentLibraryId) {
loadFolders();
lastLibraryIdRef.current = currentLibraryId;
}
// 计算预估剩余时间
const getEstimatedTime = () => {
if (!scanProgress || scanProgress.current === 0) return null;
if (scanProgress.estimatedTimeLeft !== undefined) {
const seconds = scanProgress.estimatedTimeLeft;
if (seconds < 1) return '即将完成';
if (seconds < 60) return `剩余约 ${seconds} 秒`;
const min = Math.floor(seconds / 60);
return `剩余约 ${min} 分钟`;
}
return null;
};
return () => {
if (folderDebounceRef.current) {
clearTimeout(folderDebounceRef.current);
}
};
}, [currentLibraryId, searchKeywords, filters, selectedFolder]);
// 取消当前请求(使用 requestManager 统一管理)
const cancelCurrentRequest = useCallback(() => {
// 取消所有 IMAGES 类型的请求
requestManager.cancelAll(RequestType.IMAGES);
currentRequestContextRef.current = null;
}, []);
// 加载图片 - 核心函数
const loadImages = useCallback(async () => {
if (!currentLibraryId) return;
// 递增请求ID
const requestId = ++loadingRequestRef.current;
// Optimization: If no folder selected and no search/filters, do NOT fetch images
// This prevents loading all images when showing Dashboard
// 如果没有选中文件夹且没有搜索条件,显示 Dashboard
if (!selectedFolder && !searchKeywords && filters.formats.length === 0) {
if (requestId === loadingRequestRef.current) {
setImages([]); // Clear images to save memory
setIsLoadingImages(false);
}
setImages([]);
setIsLoadingImages(false);
useStore.getState().setImageLoadingState({
isLoading: false,
loadedCount: 0,
totalCount: 0,
hasMore: false
});
return;
}
// 暂停空闲加载并取消之前的所有请求(关键!)
imageLoadService.onUserActionStart();
cancelCurrentRequest();
// 使用 requestManager 创建请求上下文
const requestContext = requestManager.createRequest(RequestType.IMAGES);
currentRequestContextRef.current = requestContext;
// 设置加载状态
setIsLoadingImages(true);
useStore.getState().setImageLoadingState({
isLoading: true,
loadedCount: 0,
totalCount: 0,
hasMore: false
});
try {
const params = {
keywords: searchKeywords,
...filters
};
// 构建请求参数
const params = { offset: 0, limit: 200 };
if (selectedFolder) params.folder = selectedFolder;
if (searchKeywords) params.keywords = searchKeywords;
if (filters.formats?.length > 0) params.formats = filters.formats.join(',');
// 只有选中了文件夹才添加 folder 参数
if (selectedFolder) {
params.folder = selectedFolder;
const startTime = Date.now();
console.log(`📂 Loading folder: ${selectedFolder || 'all'} [reqId=${requestContext.id}] [pending=${requestManager.getActiveCount(RequestType.IMAGES)}]`);
const response = await imageAPI.search(currentLibraryId, params, {
signal: requestContext.signal
});
const networkTime = Date.now() - startTime;
// 检查请求是否被取消(使用 requestManager 检查)
if (!requestManager.isValid(requestContext.id)) {
console.log(`⏹️ Request cancelled [reqId=${requestContext.id}]`);
return;
}
const response = await imageAPI.search(currentLibraryId, params);
const { images, total, hasMore } = response.data;
console.log(`✅ Loaded ${images.length}/${total} images | network=${networkTime}ms [reqId=${requestContext.id}]`);
// 标记请求完成
requestManager.complete(requestContext.id);
// 只有当这是最新的请求时才更新状态
if (requestId === loadingRequestRef.current) {
setImages(response.data.images);
// 更新状态
setImages(images);
useStore.getState().setImageLoadingState({
isLoading: false,
loadedCount: images.length,
totalCount: total || images.length,
hasMore: hasMore || false
});
// 无筛选条件时,同步更新总数
if (!selectedFolder && !searchKeywords) {
setTotalImageCount(response.data.images.length);
}
// 如果还有更多数据,恢复空闲加载
if (hasMore) {
imageLoadService.onUserActionEnd();
}
} catch (error) {
// 只有当这是最新的请求时才显示错误
if (requestId === loadingRequestRef.current) {
console.error('Error loading images:', error);
// 忽略取消错误
if (error.name === 'CanceledError' || error.name === 'AbortError') {
return;
}
console.error('Error loading images:', error);
requestManager.error(requestContext.id);
} finally {
if (requestId === loadingRequestRef.current) {
// 只有当请求仍然有效时才更新状态
if (requestManager.isValid(requestContext.id) || requestContext.status === 'completed') {
setIsLoadingImages(false);
currentRequestContextRef.current = null;
}
}
}, [currentLibraryId, searchKeywords, filters, selectedFolder, setImages, setTotalImageCount]);
}, [currentLibraryId, searchKeywords, filters, selectedFolder, setImages, cancelCurrentRequest]);
const loadFolders = async () => {
// 监听文件夹变化
useEffect(() => {
if (!currentLibraryId) return;
try {
const response = await imageAPI.getFolders(currentLibraryId);
useStore.getState().setFolders(response.data.folders);
} catch (error) {
console.error('Error loading folders:', error);
// 清除之前的防抖定时器
if (debounceTimerRef.current) {
clearTimeout(debounceTimerRef.current);
}
};
// 立即取消之前的请求(关键!)
cancelCurrentRequest();
// 立即清空图片,让 UI 快速响应
setImages([]);
// 使用防抖避免快速连续点击(150ms 足够过滤掉快速点击)
debounceTimerRef.current = setTimeout(() => {
loadImages();
}, 150);
// 更新 lastLibraryIdRef(文件夹加载已在 Sidebar 中处理)
lastLibraryIdRef.current = currentLibraryId;
return () => {
if (debounceTimerRef.current) {
clearTimeout(debounceTimerRef.current);
}
};
}, [currentLibraryId, searchKeywords, filters, selectedFolder, loadImages, cancelCurrentRequest, setImages]);
// 组件卸载时清理
useEffect(() => {
return () => {
cancelCurrentRequest();
if (debounceTimerRef.current) {
clearTimeout(debounceTimerRef.current);
}
};
}, [cancelCurrentRequest]);
// 停止扫描
const handleStopScan = async () => {
if (!currentLibraryId || isStoppingOrResuming) return;
setIsStoppingOrResuming(true);
try {
await scanAPI.stop(currentLibraryId);
@@ -176,15 +201,11 @@ function MainContent() {
// 继续扫描
const handleResumeScan = async () => {
if (!currentLibraryId || isStoppingOrResuming) return;
setIsStoppingOrResuming(true);
try {
if (scanProgress?.needsRescan) {
// 应用重启后的恢复:使用增量同步
console.log('🔄 使用增量同步恢复扫描');
await scanAPI.sync(currentLibraryId);
} else {
// 正常继续扫描
await scanAPI.resume(currentLibraryId);
}
setScanPaused(false);
@@ -195,107 +216,75 @@ function MainContent() {
}
};
// 当扫描进度变化时同步暂停状态
// 同步扫描暂停状态
useEffect(() => {
if (!scanProgress) {
setScanPaused(false);
} else if (scanProgress.isPaused) {
// 从 Sidebar/App 恢复的暂停状态
setScanPaused(true);
} else if (scanProgress.percent === 100) {
// 扫描完成时清除暂停状态
setScanPaused(false);
}
}, [scanProgress]);
return (
<div className="flex flex-col h-full bg-gray-50 dark:bg-gray-900">
{/* Scan Progress - 只有当有进度数据时才显示 */}
{/* Scan Progress */}
{scanProgress && (
<div className={`p-4 border-b ${scanPaused
? 'bg-yellow-50 dark:bg-yellow-900 border-yellow-200 dark:border-yellow-700'
: 'bg-blue-50 dark:bg-blue-900 border-blue-200 dark:border-blue-700'
}`}>
}`}>
<div className="flex items-center justify-between mb-2">
<div className={`text-sm font-medium ${scanPaused
? 'text-yellow-700 dark:text-yellow-300'
: 'text-blue-700 dark:text-blue-300'
}`}>
{scanPaused
? '扫描已暂停'
: scanProgress?.status === 'preparing'
? '正在准备扫描...'
: '正在扫描素材库,期间请勿操作,会影响扫描速度'
}
<div className={`text-sm font-medium ${scanPaused ? 'text-yellow-700 dark:text-yellow-300' : 'text-blue-700 dark:text-blue-300'}`}>
{scanPaused ? '扫描已暂停' : scanProgress?.status === 'preparing' ? '正在准备扫描...' : '正在扫描素材库'}
</div>
<div className="flex items-center gap-2">
<span className={`text-sm ${scanPaused
? 'text-yellow-600 dark:text-yellow-400'
: 'text-blue-600 dark:text-blue-400'
}`}>
<span className={`text-sm ${scanPaused ? 'text-yellow-600' : 'text-blue-600'}`}>
{scanProgress?.percent || 0}%
</span>
{/* 停止/继续按钮 */}
{(scanProgress?.canStop || scanPaused) && (
<button
onClick={scanPaused ? handleResumeScan : handleStopScan}
disabled={isStoppingOrResuming}
className={`p-1.5 rounded-md transition-colors ${scanPaused
? 'bg-green-500 hover:bg-green-600 text-white'
: 'bg-yellow-500 hover:bg-yellow-600 text-white'
} ${isStoppingOrResuming ? 'opacity-50 cursor-not-allowed' : ''}`}
title={scanPaused ? '继续扫描' : '暂停扫描'}
className={`p-1.5 rounded-md ${scanPaused ? 'bg-green-500 hover:bg-green-600' : 'bg-yellow-500 hover:bg-yellow-600'} text-white`}
>
{isStoppingOrResuming ? (
<div className="w-4 h-4 border-2 border-white border-t-transparent rounded-full animate-spin" />
) : scanPaused ? (
<Play className="w-4 h-4" />
) : (
<Pause className="w-4 h-4" />
)}
{scanPaused ? <Play className="w-4 h-4" /> : <Pause className="w-4 h-4" />}
</button>
)}
</div>
</div>
<div className={`w-full rounded-full h-2 mb-2 ${scanPaused
? 'bg-yellow-200 dark:bg-yellow-800'
: 'bg-blue-200 dark:bg-blue-800'
}`}>
<div className={`w-full rounded-full h-2 mb-2 ${scanPaused ? 'bg-yellow-200' : 'bg-blue-200'}`}>
<div
className={`h-2 rounded-full transition-all duration-300 ${scanPaused
? 'bg-yellow-500'
: scanProgress?.status === 'preparing'
? 'bg-blue-400 animate-pulse'
: 'bg-blue-500'
}`}
className={`h-2 rounded-full transition-all ${scanPaused ? 'bg-yellow-500' : 'bg-blue-500'}`}
style={{ width: `${scanProgress?.percent || 0}%` }}
/>
</div>
<div className={`flex items-center justify-between text-xs ${scanPaused
? 'text-yellow-600 dark:text-yellow-400'
: 'text-blue-600 dark:text-blue-400'
}`}>
<span>
{scanPaused
? scanProgress?.needsRescan
? `上次扫描中断于 ${scanProgress?.current || 0} 张,点击继续完成`
: `已处理 ${scanProgress?.current || 0} 张,剩余 ${scanProgress?.pendingCount || (scanProgress?.total - scanProgress?.current) || 0} 张待处理`
: scanProgress?.status === 'preparing'
? '正在初始化...'
: `已处理 ${scanProgress?.current || 0} / ${scanProgress?.total || 0} 张图片`
}
</span>
<span>
{scanPaused
? scanProgress?.needsRescan ? '需要继续' : '暂停中'
: (getEstimatedTime() || '扫描完成后将自动显示')
}
</span>
<div className={`text-xs ${scanPaused ? 'text-yellow-600' : 'text-blue-600'}`}>
已处理 {scanProgress?.current || 0} / {scanProgress?.total || 0} 张图片
{getEstimatedTime() && ` · ${getEstimatedTime()}`}
</div>
</div>
)}
{/* Content Area */}
{/* Loading Progress */}
{imageLoadingState.hasMore && imageLoadingState.loadedCount > 0 && (
<div className="px-4 py-2 bg-gray-100 dark:bg-gray-800 border-b border-gray-200 dark:border-gray-700">
<div className="flex items-center justify-between text-sm">
<span className="text-gray-600 dark:text-gray-400">
已加载 {imageLoadingState.loadedCount} / {imageLoadingState.totalCount} 张
</span>
<div className="w-32 h-1.5 bg-gray-200 rounded-full overflow-hidden">
<div
className="h-full bg-blue-500"
style={{ width: `${(imageLoadingState.loadedCount / imageLoadingState.totalCount) * 100}%` }}
/>
</div>
</div>
</div>
)}
{/* Content */}
<div className="flex-1 overflow-hidden">
{(!selectedFolder && !searchKeywords && filters.formats.length === 0) ? (
<Dashboard />
+29 -10
View File
@@ -2,6 +2,9 @@ import { useState, useMemo, useEffect, useRef } from 'react';
import { Folder, Search, ChevronRight, ChevronDown, X, Trash2, ChevronsRight, ChevronsDown } from 'lucide-react';
import useStore from '../store/useStore';
import { libraryAPI, scanAPI, imageAPI } from '../services/api';
import requestManager, { RequestType } from '../services/requestManager';
import cacheService from '../services/cacheService';
import imageLoadService from '../services/imageLoadService';
// 检查素材库是否有暂停的扫描
const checkPausedScan = async (libraryId) => {
@@ -153,25 +156,38 @@ function Sidebar() {
setIsSwitching(true);
try {
// 切换前清理当前素材库的状态
// 1. 暂停空闲加载并取消所有之前的请求
imageLoadService.onUserActionStart();
requestManager.cancelAllRequests();
// 2. 清理当前素材库的状态(立即响应)
useStore.getState().setScanProgress(null);
useStore.getState().setSelectedImage(null);
useStore.getState().setImages([]);
useStore.getState().setFolders([]);
useStore.getState().setImageLoadingState({
isLoading: false,
loadedCount: 0,
totalCount: 0,
hasMore: false
});
setSelectedFolder(null);
// 并行执行:切换素材库 + 预加载数据
const [, foldersRes, imagesRes] = await Promise.all([
libraryAPI.setCurrent(libraryId),
// 3. 先切换素材库(确保后端数据库连接已切换)
await libraryAPI.setCurrent(libraryId);
// 4. 然后并行加载文件夹和总数
const [foldersRes, countRes] = await Promise.all([
imageAPI.getFolders(libraryId),
imageAPI.search(libraryId, {})
imageAPI.getCount(libraryId)
]);
// 更新状态
setCurrentLibrary(libraryId);
// 5. 更新状态(包括 currentLibraryId,这样其他组件才会响应)
useStore.getState().setFolders(foldersRes.data.folders);
useStore.getState().setImages(imagesRes.data.images);
useStore.getState().setTotalImageCount(imagesRes.data.images.length);
useStore.getState().setTotalImageCount(countRes.data.count);
setCurrentLibrary(libraryId); // 最后才更新 currentLibraryId
// 后台检查新素材库是否有暂停的扫描(不阻塞主流程)
// 7. 后台检查新素材库是否有暂停的扫描(不阻塞主流程)
checkPausedScan(libraryId).then(scanStatus => {
if (scanStatus && scanStatus.status === 'paused') {
if (scanStatus.needsRescan) {
@@ -199,6 +215,7 @@ function Sidebar() {
} catch (error) {
console.error('Error setting current library:', error);
alert('切换素材库失败: ' + error.message);
useStore.getState().setImageLoadingState({ isLoading: false });
} finally {
setIsSwitching(false);
}
@@ -371,6 +388,8 @@ function Sidebar() {
// 如果是第一次点击(未选中),则选中
if (selectedFolder !== folder.path) {
// 暂停空闲加载
imageLoadService.onUserActionStart();
setSelectedFolder(folder.path);
} else if (hasChildren) {
// 如果已经选中,且有子文件夹,则展开/折叠
@@ -0,0 +1,297 @@
/**
* 素材库切换优化 - 组件集成测试
*
* **Feature: library-switch-optimization**
* **Property 1: Request cancellation on library switch**
* **Property 2: Memory cleanup on library switch**
* **Property 3: Request cancellation on folder switch**
* **Property 5: Debounce rapid folder clicks**
* **Property 6: Background loading pauses on user action**
* **Property 9: Only latest request result applied**
* **Property 10: Unmount cancels all requests**
* **Validates: Requirements 1.2, 1.3, 2.2, 3.2, 3.3, 4.3, 4.4**
*/
import { describe, it, expect, beforeEach, vi } from 'vitest';
import * as fc from 'fast-check';
import { RequestManager, RequestType } from '../services/requestManager.js';
describe('Library Switch Optimization - Integration Properties', () => {
/**
* **Property 1: Request cancellation on library switch**
* *For any* library switch operation, all pending requests from the previous
* library should be cancelled (aborted) before new requests are initiated.
*/
describe('Property 1: Request cancellation on library switch', () => {
it('should cancel all pending requests when switching libraries', () => {
fc.assert(
fc.property(
fc.integer({ min: 1, max: 10 }),
fc.integer({ min: 1, max: 10 }),
(pendingCount, newRequestCount) => {
const manager = new RequestManager();
const pendingContexts = [];
// 创建待处理的请求(模拟旧素材库的请求)
for (let i = 0; i < pendingCount; i++) {
pendingContexts.push(manager.createRequest(RequestType.IMAGES));
}
// 验证请求都是活跃的
const allActive = pendingContexts.every(ctx => ctx.isActive);
// 模拟切换素材库:取消所有请求
manager.cancelAllRequests();
// 验证所有旧请求都被取消
const allCancelled = pendingContexts.every(ctx => !ctx.isActive && ctx.signal.aborted);
// 创建新请求(模拟新素材库的请求)
const newContexts = [];
for (let i = 0; i < newRequestCount; i++) {
newContexts.push(manager.createRequest(RequestType.IMAGES));
}
// 验证新请求是活跃的
const newAllActive = newContexts.every(ctx => ctx.isActive);
return allActive && allCancelled && newAllActive;
}
),
{ numRuns: 100 }
);
});
});
/**
* **Property 2: Memory cleanup on library switch**
* *For any* library switch operation, the previous library's image data
* should be cleared from the store state.
*/
describe('Property 2: Memory cleanup on library switch', () => {
it('should clear previous library data before loading new data', () => {
fc.assert(
fc.property(
fc.array(fc.record({ id: fc.integer(), path: fc.string() }), { minLength: 1, maxLength: 100 }),
fc.array(fc.record({ id: fc.integer(), path: fc.string() }), { minLength: 1, maxLength: 100 }),
(oldImages, newImages) => {
// 模拟 store 状态
let storeState = {
images: oldImages,
filteredImages: oldImages
};
// 模拟切换素材库时的清理
storeState = {
images: [],
filteredImages: []
};
// 验证清理后状态为空
const clearedCorrectly = storeState.images.length === 0;
// 模拟加载新数据
storeState = {
images: newImages,
filteredImages: newImages
};
// 验证新数据正确加载
const newDataLoaded = storeState.images.length === newImages.length;
return clearedCorrectly && newDataLoaded;
}
),
{ numRuns: 100 }
);
});
});
/**
* **Property 3: Request cancellation on folder switch**
* *For any* folder selection while a previous folder's images are still loading,
* the previous folder's loading request should be cancelled.
*/
describe('Property 3: Request cancellation on folder switch', () => {
it('should cancel previous folder request when switching folders', () => {
fc.assert(
fc.property(
fc.string({ minLength: 1, maxLength: 20 }),
fc.string({ minLength: 1, maxLength: 20 }),
(folder1, folder2) => {
const manager = new RequestManager();
// 创建第一个文件夹的请求
const request1 = manager.createRequest(RequestType.IMAGES);
expect(request1.isActive).toBe(true);
// 切换到第二个文件夹:取消之前的请求
manager.cancelAll(RequestType.IMAGES);
// 验证第一个请求被取消
expect(request1.isActive).toBe(false);
expect(request1.signal.aborted).toBe(true);
// 创建第二个文件夹的请求
const request2 = manager.createRequest(RequestType.IMAGES);
expect(request2.isActive).toBe(true);
return true;
}
),
{ numRuns: 100 }
);
});
});
/**
* **Property 5: Debounce rapid folder clicks**
* *For any* sequence of rapid folder clicks (within debounce window),
* only the final folder selection should result in a completed request.
*/
describe('Property 5: Debounce rapid folder clicks', () => {
it('should only keep the latest request active after rapid cancellations', () => {
fc.assert(
fc.property(
fc.integer({ min: 2, max: 20 }),
(clickCount) => {
const manager = new RequestManager();
const requests = [];
// 模拟快速点击多个文件夹
for (let i = 0; i < clickCount; i++) {
// 取消之前的请求
manager.cancelAll(RequestType.IMAGES);
// 创建新请求
requests.push(manager.createRequest(RequestType.IMAGES));
}
// 只有最后一个请求应该是活跃的
const activeCount = requests.filter(r => r.isActive).length;
const lastIsActive = requests[requests.length - 1].isActive;
const othersInactive = requests.slice(0, -1).every(r => !r.isActive);
return activeCount === 1 && lastIsActive && othersInactive;
}
),
{ numRuns: 100 }
);
});
});
/**
* **Property 9: Only latest request result applied**
* *For any* sequence of requests for the same resource, only the result
* of the most recently initiated request should be applied.
*/
describe('Property 9: Only latest request result applied', () => {
it('should only apply result if request is still valid', () => {
fc.assert(
fc.property(
fc.integer({ min: 2, max: 10 }),
(requestCount) => {
const manager = new RequestManager();
const requests = [];
// 创建多个请求
for (let i = 0; i < requestCount; i++) {
requests.push(manager.createRequest(RequestType.IMAGES));
}
// 取消除最后一个外的所有请求
for (let i = 0; i < requestCount - 1; i++) {
requests[i].cancel();
}
// 验证只有最后一个请求有效
const validCount = requests.filter(r => manager.isValid(r.id)).length;
return validCount === 1 && manager.isValid(requests[requestCount - 1].id);
}
),
{ numRuns: 100 }
);
});
});
/**
* **Property 10: Unmount cancels all requests**
* *For any* component unmount event, all pending requests should be cancelled.
*/
describe('Property 10: Unmount cancels all requests', () => {
it('should cancel all requests on unmount', () => {
fc.assert(
fc.property(
fc.integer({ min: 1, max: 20 }),
(requestCount) => {
const manager = new RequestManager();
const requests = [];
// 创建多个不同类型的请求
for (let i = 0; i < requestCount; i++) {
const type = Object.values(RequestType)[i % 3];
requests.push(manager.createRequest(type));
}
// 模拟组件卸载:取消所有请求
manager.cancelAllRequests();
// 验证所有请求都被取消
const allCancelled = requests.every(r => !r.isActive && r.signal.aborted);
return allCancelled;
}
),
{ numRuns: 100 }
);
});
});
/**
* **Property 6: Background loading pauses on user action**
* *For any* user-initiated action while background loading is in progress,
* the background loading should pause.
*/
describe('Property 6: Background loading pauses on user action', () => {
it('should track pause state correctly', () => {
// 模拟空闲加载状态
let idlePaused = false;
let isIdleLoading = true;
const pauseIdleLoading = () => {
idlePaused = true;
isIdleLoading = false;
};
const resumeIdleLoading = () => {
idlePaused = false;
isIdleLoading = true;
};
fc.assert(
fc.property(
fc.array(fc.boolean(), { minLength: 1, maxLength: 20 }),
(actions) => {
// 重置状态
idlePaused = false;
isIdleLoading = true;
for (const shouldPause of actions) {
if (shouldPause) {
pauseIdleLoading();
// 用户操作时应该暂停
if (!idlePaused || isIdleLoading) return false;
} else {
resumeIdleLoading();
// 恢复后应该继续
if (idlePaused || !isIdleLoading) return false;
}
}
return true;
}
),
{ numRuns: 100 }
);
});
});
});
+3 -2
View File
@@ -15,15 +15,16 @@ export const libraryAPI = {
// Image API
export const imageAPI = {
search: (libraryId, params = {}) => {
search: (libraryId, params = {}, options = {}) => {
const query = new URLSearchParams({
libraryId,
...params
});
return axios.get(`${API_BASE}/image?${query}`);
return axios.get(`${API_BASE}/image?${query}`, options);
},
getCount: (libraryId) => axios.get(`${API_BASE}/image/count?libraryId=${libraryId}`),
getFolders: (libraryId) => axios.get(`${API_BASE}/image/folders?libraryId=${libraryId}`),
getCacheMeta: (libraryId) => axios.get(`${API_BASE}/image/cache-meta?libraryId=${libraryId}`),
getThumbnailUrl: (libraryId, size, filename) => `${API_BASE}/image/thumbnail/${libraryId}/${size}/${filename}`,
getOriginalUrl: (libraryId, path) => `${API_BASE}/image/original/${libraryId}/${path}`,
openInExplorer: (libraryId, path) => axios.post(`${API_BASE}/image/${libraryId}/open-file`, { path })
+469
View File
@@ -0,0 +1,469 @@
/**
* CacheService - 前端缓存服务
* 管理素材库和文件夹的图片元数据缓存
*/
import { imageAPI } from './api';
// 缓存版本号,用于处理缓存格式升级
const CACHE_VERSION = 1;
// IndexedDB 数据库名称
const DB_NAME = 'flypic_cache';
const DB_VERSION = 1;
// 存储名称
const STORE_LIBRARY = 'library_cache';
const STORE_FOLDER = 'folder_cache';
// LRU 缓存最大文件夹数量
const MAX_FOLDER_CACHE = 50;
class CacheService {
constructor() {
this.db = null;
this.dbReady = this.initDB();
// 文件夹访问时间记录(用于 LRU)
this.folderAccessTimes = new Map();
}
/**
* 初始化 IndexedDB
*/
async initDB() {
return new Promise((resolve, reject) => {
const request = indexedDB.open(DB_NAME, DB_VERSION);
request.onerror = () => {
console.error('Failed to open IndexedDB:', request.error);
reject(request.error);
};
request.onsuccess = () => {
this.db = request.result;
resolve(this.db);
};
request.onupgradeneeded = (event) => {
const db = event.target.result;
// 素材库缓存存储
if (!db.objectStoreNames.contains(STORE_LIBRARY)) {
db.createObjectStore(STORE_LIBRARY, { keyPath: 'libraryId' });
}
// 文件夹缓存存储
if (!db.objectStoreNames.contains(STORE_FOLDER)) {
const folderStore = db.createObjectStore(STORE_FOLDER, { keyPath: 'cacheKey' });
folderStore.createIndex('libraryId', 'libraryId', { unique: false });
folderStore.createIndex('accessedAt', 'accessedAt', { unique: false });
}
};
});
}
/**
* 确保数据库已就绪
*/
async ensureDB() {
if (!this.db) {
await this.dbReady;
}
return this.db;
}
/**
* 生成文件夹缓存键
*/
getFolderCacheKey(libraryId, folder) {
return `${libraryId}:${folder || '__all__'}`;
}
// ==================== 素材库缓存 ====================
/**
* 获取素材库缓存
* @param {string} libraryId
* @returns {Promise<LibraryCache|null>}
*/
async getLibraryCache(libraryId) {
try {
const db = await this.ensureDB();
return new Promise((resolve, reject) => {
const tx = db.transaction(STORE_LIBRARY, 'readonly');
const store = tx.objectStore(STORE_LIBRARY);
const request = store.get(libraryId);
request.onsuccess = () => {
const cache = request.result;
if (cache && cache.version === CACHE_VERSION) {
resolve(cache);
} else {
resolve(null);
}
};
request.onerror = () => reject(request.error);
});
} catch (error) {
console.warn('Failed to get library cache:', error);
return null;
}
}
/**
* 保存素材库缓存
* @param {string} libraryId
* @param {object} data - { folders, totalCount, dbModifiedAt }
*/
async saveLibraryCache(libraryId, data) {
try {
const db = await this.ensureDB();
return new Promise((resolve, reject) => {
const tx = db.transaction(STORE_LIBRARY, 'readwrite');
const store = tx.objectStore(STORE_LIBRARY);
const cache = {
libraryId,
version: CACHE_VERSION,
createdAt: Date.now(),
dbModifiedAt: data.dbModifiedAt,
totalCount: data.totalCount,
folders: data.folders
};
const request = store.put(cache);
request.onsuccess = () => resolve();
request.onerror = () => reject(request.error);
});
} catch (error) {
console.warn('Failed to save library cache:', error);
}
}
/**
* 验证素材库缓存是否有效
* @param {string} libraryId
* @returns {Promise<CacheValidation>}
*/
async validateLibraryCache(libraryId) {
try {
const cache = await this.getLibraryCache(libraryId);
if (!cache) {
return { isValid: false, reason: 'not_found' };
}
// 从后端获取当前数据库修改时间
const response = await imageAPI.getCacheMeta(libraryId);
const currentDbModifiedAt = response.data.dbModifiedAt;
if (cache.dbModifiedAt >= currentDbModifiedAt) {
return {
isValid: true,
cache,
dbModifiedAt: currentDbModifiedAt,
cacheModifiedAt: cache.dbModifiedAt
};
} else {
return {
isValid: false,
reason: 'stale',
dbModifiedAt: currentDbModifiedAt,
cacheModifiedAt: cache.dbModifiedAt
};
}
} catch (error) {
console.warn('Failed to validate library cache:', error);
return { isValid: false, reason: 'error' };
}
}
// ==================== 文件夹缓存 ====================
/**
* 获取文件夹缓存
* @param {string} libraryId
* @param {string|null} folder
* @returns {Promise<FolderCache|null>}
*/
async getFolderCache(libraryId, folder) {
try {
const db = await this.ensureDB();
const cacheKey = this.getFolderCacheKey(libraryId, folder);
return new Promise((resolve, reject) => {
const tx = db.transaction(STORE_FOLDER, 'readwrite');
const store = tx.objectStore(STORE_FOLDER);
const request = store.get(cacheKey);
request.onsuccess = () => {
const cache = request.result;
if (cache && cache.version === CACHE_VERSION) {
// 更新访问时间
cache.accessedAt = Date.now();
store.put(cache);
this.folderAccessTimes.set(cacheKey, cache.accessedAt);
resolve(cache);
} else {
resolve(null);
}
};
request.onerror = () => reject(request.error);
});
} catch (error) {
console.warn('Failed to get folder cache:', error);
return null;
}
}
/**
* 保存文件夹缓存
* @param {string} libraryId
* @param {string|null} folder
* @param {Array} images
* @param {number} dbModifiedAt
*/
async saveFolderCache(libraryId, folder, images, dbModifiedAt) {
try {
const db = await this.ensureDB();
const cacheKey = this.getFolderCacheKey(libraryId, folder);
const now = Date.now();
// 先检查是否需要 LRU 驱逐(全局检查)
await this.evictIfNeeded(null, true);
return new Promise((resolve, reject) => {
const tx = db.transaction(STORE_FOLDER, 'readwrite');
const store = tx.objectStore(STORE_FOLDER);
// 精简图片数据,只保留必要字段
const slimImages = images.map(img => ({
id: img.id,
path: img.path,
filename: img.filename,
width: img.width,
height: img.height,
thumbnail_path: img.thumbnail_path,
file_type: img.file_type,
created_at: img.created_at,
format: img.format
}));
const cache = {
cacheKey,
libraryId,
folder: folder || '__all__',
version: CACHE_VERSION,
cachedAt: now,
accessedAt: now,
dbModifiedAt,
imageCount: images.length,
images: slimImages
};
const request = store.put(cache);
request.onsuccess = () => {
this.folderAccessTimes.set(cacheKey, now);
resolve();
};
request.onerror = () => reject(request.error);
});
} catch (error) {
console.warn('Failed to save folder cache:', error);
}
}
/**
* LRU 驱逐:如果缓存数量超过阈值,删除最久未访问的缓存
* @param {string} libraryId - 当前素材库ID(可选,如果提供则只检查该素材库)
* @param {boolean} global - 是否检查全局缓存数量
*/
async evictIfNeeded(libraryId, global = false) {
try {
const db = await this.ensureDB();
return new Promise((resolve, reject) => {
const tx = db.transaction(STORE_FOLDER, 'readwrite');
const store = tx.objectStore(STORE_FOLDER);
// 获取所有缓存或特定素材库的缓存
let request;
if (global || !libraryId) {
request = store.getAll();
} else {
const index = store.index('libraryId');
request = index.getAll(libraryId);
}
request.onsuccess = () => {
const caches = request.result;
if (caches.length >= MAX_FOLDER_CACHE) {
// 按访问时间排序(最旧的在前)
caches.sort((a, b) => (a.accessedAt || 0) - (b.accessedAt || 0));
// 计算需要删除的数量:保留 MAX_FOLDER_CACHE - 1 个,为新缓存腾出空间
const deleteCount = caches.length - MAX_FOLDER_CACHE + 1;
const toDelete = caches.slice(0, deleteCount);
console.log(`🗑️ LRU eviction: removing ${toDelete.length} folder caches`);
for (const cache of toDelete) {
store.delete(cache.cacheKey);
this.folderAccessTimes.delete(cache.cacheKey);
}
}
resolve();
};
request.onerror = () => reject(request.error);
});
} catch (error) {
console.warn('Failed to evict cache:', error);
}
}
/**
* 获取当前缓存统计信息
* @returns {Promise<{libraryCount: number, folderCount: number, totalSize: number}>}
*/
async getCacheStats() {
try {
const db = await this.ensureDB();
const libraryCount = await new Promise((resolve, reject) => {
const tx = db.transaction(STORE_LIBRARY, 'readonly');
const store = tx.objectStore(STORE_LIBRARY);
const request = store.count();
request.onsuccess = () => resolve(request.result);
request.onerror = () => reject(request.error);
});
const folderCount = await new Promise((resolve, reject) => {
const tx = db.transaction(STORE_FOLDER, 'readonly');
const store = tx.objectStore(STORE_FOLDER);
const request = store.count();
request.onsuccess = () => resolve(request.result);
request.onerror = () => reject(request.error);
});
return { libraryCount, folderCount };
} catch (error) {
console.warn('Failed to get cache stats:', error);
return { libraryCount: 0, folderCount: 0 };
}
}
/**
* 获取最近访问的文件夹缓存列表
* @param {number} limit - 返回数量限制
* @returns {Promise<Array<{cacheKey: string, folder: string, accessedAt: number}>>}
*/
async getRecentFolderCaches(limit = 10) {
try {
const db = await this.ensureDB();
return new Promise((resolve, reject) => {
const tx = db.transaction(STORE_FOLDER, 'readonly');
const store = tx.objectStore(STORE_FOLDER);
const index = store.index('accessedAt');
// 使用游标从最新到最旧遍历
const results = [];
const request = index.openCursor(null, 'prev');
request.onsuccess = (event) => {
const cursor = event.target.result;
if (cursor && results.length < limit) {
const cache = cursor.value;
results.push({
cacheKey: cache.cacheKey,
libraryId: cache.libraryId,
folder: cache.folder,
accessedAt: cache.accessedAt,
imageCount: cache.imageCount
});
cursor.continue();
} else {
resolve(results);
}
};
request.onerror = () => reject(request.error);
});
} catch (error) {
console.warn('Failed to get recent folder caches:', error);
return [];
}
}
// ==================== 缓存失效 ====================
/**
* 清除素材库的所有缓存
* @param {string} libraryId
*/
async invalidateLibrary(libraryId) {
try {
const db = await this.ensureDB();
// 删除素材库缓存
await new Promise((resolve, reject) => {
const tx = db.transaction(STORE_LIBRARY, 'readwrite');
const store = tx.objectStore(STORE_LIBRARY);
const request = store.delete(libraryId);
request.onsuccess = () => resolve();
request.onerror = () => reject(request.error);
});
// 删除该素材库的所有文件夹缓存
await new Promise((resolve, reject) => {
const tx = db.transaction(STORE_FOLDER, 'readwrite');
const store = tx.objectStore(STORE_FOLDER);
const index = store.index('libraryId');
const request = index.getAllKeys(libraryId);
request.onsuccess = () => {
const keys = request.result;
for (const key of keys) {
store.delete(key);
this.folderAccessTimes.delete(key);
}
resolve();
};
request.onerror = () => reject(request.error);
});
} catch (error) {
console.warn('Failed to invalidate library cache:', error);
}
}
/**
* 清除特定文件夹的缓存
* @param {string} libraryId
* @param {string|null} folder
*/
async invalidateFolder(libraryId, folder) {
try {
const db = await this.ensureDB();
const cacheKey = this.getFolderCacheKey(libraryId, folder);
return new Promise((resolve, reject) => {
const tx = db.transaction(STORE_FOLDER, 'readwrite');
const store = tx.objectStore(STORE_FOLDER);
const request = store.delete(cacheKey);
request.onsuccess = () => {
this.folderAccessTimes.delete(cacheKey);
resolve();
};
request.onerror = () => reject(request.error);
});
} catch (error) {
console.warn('Failed to invalidate folder cache:', error);
}
}
}
// 单例实例
const cacheService = new CacheService();
export default cacheService;
export { CacheService, MAX_FOLDER_CACHE };
+269
View File
@@ -0,0 +1,269 @@
/**
* CacheService 属性测试
* 使用 fast-check 进行属性测试
*
* 注意:这些测试需要模拟 IndexedDB,在 Node 环境下使用 fake-indexeddb
*/
import { describe, it, expect, beforeEach, vi } from 'vitest';
import * as fc from 'fast-check';
// 模拟缓存验证逻辑(不依赖 IndexedDB 的纯函数测试)
describe('Cache Validation Logic', () => {
/**
* **Feature: library-switch-optimization, Property 14: Cache validation compares timestamps**
* *For any* cache validation operation, the system should compare the cache's
* dbModifiedAt timestamp with the current database modification timestamp.
* **Validates: Requirements 6.3**
*/
describe('Property 14: Cache validation compares timestamps', () => {
// 纯函数:验证缓存是否有效
const isCacheValid = (cacheTimestamp, dbTimestamp) => {
return cacheTimestamp >= dbTimestamp;
};
it('should return true when cache timestamp >= db timestamp', () => {
fc.assert(
fc.property(
fc.integer({ min: 0, max: Number.MAX_SAFE_INTEGER }),
fc.integer({ min: 0, max: Number.MAX_SAFE_INTEGER }),
(cacheTs, dbTs) => {
// 确保 cacheTs >= dbTs
const adjustedCacheTs = Math.max(cacheTs, dbTs);
return isCacheValid(adjustedCacheTs, dbTs) === true;
}
),
{ numRuns: 100 }
);
});
it('should return false when cache timestamp < db timestamp', () => {
fc.assert(
fc.property(
fc.integer({ min: 0, max: Number.MAX_SAFE_INTEGER - 1 }),
fc.integer({ min: 1, max: Number.MAX_SAFE_INTEGER }),
(cacheTs, offset) => {
// 确保 dbTs > cacheTs
const dbTs = cacheTs + offset;
if (dbTs > Number.MAX_SAFE_INTEGER) return true; // 跳过溢出情况
return isCacheValid(cacheTs, dbTs) === false;
}
),
{ numRuns: 100 }
);
});
it('should handle equal timestamps as valid', () => {
fc.assert(
fc.property(
fc.integer({ min: 0, max: Number.MAX_SAFE_INTEGER }),
(timestamp) => {
return isCacheValid(timestamp, timestamp) === true;
}
),
{ numRuns: 100 }
);
});
});
/**
* **Feature: library-switch-optimization, Property 15: Stale cache triggers reload**
* *For any* cache where dbModifiedAt < current database modification timestamp,
* the cache should be invalidated and data should be reloaded from database.
* **Validates: Requirements 6.4**
*/
describe('Property 15: Stale cache triggers reload', () => {
// 模拟缓存验证结果
const validateCache = (cacheTimestamp, dbTimestamp) => {
if (cacheTimestamp === null) {
return { isValid: false, reason: 'not_found' };
}
if (cacheTimestamp >= dbTimestamp) {
return { isValid: true };
}
return { isValid: false, reason: 'stale' };
};
it('should mark cache as stale when db is newer', () => {
fc.assert(
fc.property(
fc.integer({ min: 0, max: Number.MAX_SAFE_INTEGER - 1 }),
fc.integer({ min: 1, max: 1000000 }),
(cacheTs, offset) => {
const dbTs = cacheTs + offset;
if (dbTs > Number.MAX_SAFE_INTEGER) return true;
const result = validateCache(cacheTs, dbTs);
return result.isValid === false && result.reason === 'stale';
}
),
{ numRuns: 100 }
);
});
it('should mark cache as valid when cache is newer or equal', () => {
fc.assert(
fc.property(
fc.integer({ min: 0, max: Number.MAX_SAFE_INTEGER }),
fc.integer({ min: 0, max: 1000000 }),
(dbTs, offset) => {
const cacheTs = dbTs + offset;
if (cacheTs > Number.MAX_SAFE_INTEGER) return true;
const result = validateCache(cacheTs, dbTs);
return result.isValid === true;
}
),
{ numRuns: 100 }
);
});
it('should return not_found when cache is null', () => {
fc.assert(
fc.property(
fc.integer({ min: 0, max: Number.MAX_SAFE_INTEGER }),
(dbTs) => {
const result = validateCache(null, dbTs);
return result.isValid === false && result.reason === 'not_found';
}
),
{ numRuns: 100 }
);
});
});
});
describe('LRU Cache Eviction Logic', () => {
/**
* **Feature: library-switch-optimization, Property 18: LRU cache eviction**
* *For any* state where folder cache count exceeds the maximum threshold,
* the least recently used folder cache should be evicted first.
* **Validates: Requirements 7.4**
*/
describe('Property 18: LRU cache eviction', () => {
// 模拟 LRU 缓存
class MockLRUCache {
constructor(maxSize) {
this.maxSize = maxSize;
this.cache = new Map();
}
get(key) {
if (this.cache.has(key)) {
const value = this.cache.get(key);
// 移到末尾(最近使用)
this.cache.delete(key);
this.cache.set(key, { ...value, accessedAt: Date.now() });
return value;
}
return null;
}
set(key, value) {
// 如果已存在,先删除
if (this.cache.has(key)) {
this.cache.delete(key);
}
// 如果超过容量,删除最旧的
while (this.cache.size >= this.maxSize) {
const oldestKey = this.cache.keys().next().value;
this.cache.delete(oldestKey);
}
this.cache.set(key, { ...value, accessedAt: Date.now() });
}
size() {
return this.cache.size;
}
has(key) {
return this.cache.has(key);
}
}
it('should never exceed max size', () => {
fc.assert(
fc.property(
fc.integer({ min: 1, max: 20 }),
fc.array(fc.string(), { minLength: 1, maxLength: 50 }),
(maxSize, keys) => {
const cache = new MockLRUCache(maxSize);
for (const key of keys) {
cache.set(key, { data: key });
}
return cache.size() <= maxSize;
}
),
{ numRuns: 100 }
);
});
it('should evict oldest items first', () => {
fc.assert(
fc.property(
fc.integer({ min: 2, max: 10 }),
(maxSize) => {
const cache = new MockLRUCache(maxSize);
// 添加 maxSize 个项目
for (let i = 0; i < maxSize; i++) {
cache.set(`key${i}`, { data: i });
}
// 访问第一个项目(使其成为最近使用)
cache.get('key0');
// 添加新项目,应该驱逐 key1(最旧的未访问项)
cache.set('newKey', { data: 'new' });
// key0 应该还在(因为刚访问过)
// key1 应该被驱逐
return cache.has('key0') && !cache.has('key1') && cache.has('newKey');
}
),
{ numRuns: 100 }
);
});
it('should keep recently accessed items', () => {
fc.assert(
fc.property(
fc.integer({ min: 3, max: 10 }),
fc.integer({ min: 0, max: 9 }),
(maxSize, accessIndex) => {
const cache = new MockLRUCache(maxSize);
const safeAccessIndex = accessIndex % maxSize;
// 添加 maxSize 个项目
for (let i = 0; i < maxSize; i++) {
cache.set(`key${i}`, { data: i });
}
// 访问指定索引的项目(使其成为最近使用)
cache.get(`key${safeAccessIndex}`);
// 只添加一个新项目来触发一次驱逐
cache.set('newKey', { data: 'new' });
// 被访问的项目应该还在(因为它是最近访问的)
// 除非它是 key0(最早添加的),在这种情况下它会被移到末尾
// 所以被驱逐的应该是最早添加且未被访问的项目
const accessedItemExists = cache.has(`key${safeAccessIndex}`);
// 如果访问的是 key0,那么 key1 应该被驱逐
// 如果访问的是其他 key,那么 key0 应该被驱逐
if (safeAccessIndex === 0) {
return accessedItemExists && !cache.has('key1');
} else {
return accessedItemExists && !cache.has('key0');
}
}
),
{ numRuns: 100 }
);
});
});
});
+377
View File
@@ -0,0 +1,377 @@
/**
* ImageLoadService - 图片分批加载服务
* 支持分页加载、空闲加载、缓存优先
*/
import { imageAPI } from './api';
import requestManager, { RequestType } from './requestManager';
import cacheService from './cacheService';
// 默认批次大小
const DEFAULT_BATCH_SIZE = 200;
// 空闲加载延迟(毫秒)
const IDLE_LOAD_DELAY = 500;
class ImageLoadService {
constructor() {
// 当前加载状态
this.state = {
libraryId: null,
folder: null,
images: [],
offset: 0,
total: 0,
hasMore: false,
isLoading: false,
isIdleLoading: false
};
// 空闲加载定时器
this.idleTimer = null;
// 空闲加载是否暂停
this.idlePaused = false;
// 状态变化回调
this.onStateChange = null;
}
/**
* 设置状态变化回调
*/
setOnStateChange(callback) {
this.onStateChange = callback;
}
/**
* 更新状态并通知
*/
updateState(updates) {
this.state = { ...this.state, ...updates };
if (this.onStateChange) {
this.onStateChange(this.state);
}
}
/**
* 重置状态
*/
reset() {
this.cancelIdleLoading();
this.state = {
libraryId: null,
folder: null,
images: [],
offset: 0,
total: 0,
hasMore: false,
isLoading: false,
isIdleLoading: false
};
}
/**
* 加载文件夹的第一批图片
* @param {string} libraryId
* @param {string|null} folder
* @param {object} options - { batchSize, useCache }
*/
async loadInitialBatch(libraryId, folder, options = {}) {
const { batchSize = DEFAULT_BATCH_SIZE, useCache = true } = options;
// 暂停并取消之前的空闲加载
this.pauseIdleLoading();
// 取消之前的请求
requestManager.cancelAll(RequestType.IMAGES);
// 更新状态
this.updateState({
libraryId,
folder,
images: [],
offset: 0,
total: 0,
hasMore: false,
isLoading: true
});
// 尝试从缓存加载
if (useCache) {
try {
const cachedData = await cacheService.getFolderCache(libraryId, folder);
if (cachedData) {
// 验证缓存是否有效
const metaResponse = await imageAPI.getCacheMeta(libraryId);
const dbModifiedAt = metaResponse.data.dbModifiedAt;
if (cachedData.dbModifiedAt >= dbModifiedAt) {
// 缓存有效,直接使用
console.log(`📦 Using cached data for folder: ${folder || 'all'}`);
this.updateState({
images: cachedData.images,
offset: cachedData.images.length,
total: cachedData.imageCount,
hasMore: false,
isLoading: false
});
return {
images: cachedData.images,
total: cachedData.imageCount,
hasMore: false,
fromCache: true
};
} else {
// 缓存过期,清除
await cacheService.invalidateFolder(libraryId, folder);
}
}
} catch (error) {
console.warn('Cache check failed:', error);
}
}
// 从 API 加载
const requestContext = requestManager.createRequest(RequestType.IMAGES);
try {
const params = {
offset: 0,
limit: batchSize
};
if (folder) {
params.folder = folder;
}
const response = await imageAPI.search(libraryId, params, {
signal: requestContext.signal
});
// 检查请求是否仍然有效
if (!requestManager.isValid(requestContext.id)) {
return null;
}
const { images, total, hasMore } = response.data;
this.updateState({
images,
offset: images.length,
total,
hasMore,
isLoading: false
});
requestManager.complete(requestContext.id);
// 如果还有更多数据,启动空闲加载
if (hasMore) {
this.startIdleLoading();
} else {
// 加载完成,保存到缓存
this.saveToCacheAsync(libraryId, folder, images);
}
return { images, total, hasMore, fromCache: false };
} catch (error) {
if (error.name === 'CanceledError' || error.name === 'AbortError') {
return null;
}
requestManager.error(requestContext.id);
this.updateState({ isLoading: false });
throw error;
}
}
/**
* 用户操作开始时调用,暂停空闲加载并取消所有进行中的请求
*/
onUserActionStart() {
this.pauseIdleLoading();
// 关键:取消所有正在进行的图片请求,避免阻塞新请求
requestManager.cancelAll(RequestType.IMAGES);
}
/**
* 用户操作结束时调用,恢复空闲加载
*/
onUserActionEnd() {
// 延迟恢复,避免频繁切换
setTimeout(() => {
if (this.state.hasMore && !this.state.isLoading) {
this.resumeIdleLoading();
}
}, 300);
}
/**
* 加载下一批图片
*/
async loadNextBatch(batchSize = DEFAULT_BATCH_SIZE) {
if (!this.state.hasMore || this.state.isLoading) {
return null;
}
const { libraryId, folder, offset, images } = this.state;
const requestContext = requestManager.createRequest(RequestType.IMAGES);
this.updateState({ isLoading: true });
try {
const params = {
offset,
limit: batchSize
};
if (folder) {
params.folder = folder;
}
const response = await imageAPI.search(libraryId, params, {
signal: requestContext.signal
});
if (!requestManager.isValid(requestContext.id)) {
return null;
}
const newImages = response.data.images;
const allImages = [...images, ...newImages];
this.updateState({
images: allImages,
offset: allImages.length,
total: response.data.total,
hasMore: response.data.hasMore,
isLoading: false
});
requestManager.complete(requestContext.id);
// 如果加载完成,保存到缓存
if (!response.data.hasMore) {
this.saveToCacheAsync(libraryId, folder, allImages);
}
return {
images: newImages,
total: response.data.total,
hasMore: response.data.hasMore
};
} catch (error) {
if (error.name === 'CanceledError' || error.name === 'AbortError') {
return null;
}
requestManager.error(requestContext.id);
this.updateState({ isLoading: false });
throw error;
}
}
/**
* 启动空闲加载
*/
startIdleLoading() {
if (this.idleTimer || this.idlePaused) {
return;
}
this.updateState({ isIdleLoading: true });
const loadNext = async () => {
if (this.idlePaused || !this.state.hasMore) {
this.updateState({ isIdleLoading: false });
return;
}
try {
await this.loadNextBatch();
if (this.state.hasMore && !this.idlePaused) {
// 使用 requestIdleCallback 或 setTimeout
if (typeof requestIdleCallback !== 'undefined') {
this.idleTimer = requestIdleCallback(() => {
this.idleTimer = null;
loadNext();
}, { timeout: 2000 });
} else {
this.idleTimer = setTimeout(() => {
this.idleTimer = null;
loadNext();
}, IDLE_LOAD_DELAY);
}
} else {
this.updateState({ isIdleLoading: false });
}
} catch (error) {
console.error('Idle loading error:', error);
this.updateState({ isIdleLoading: false });
}
};
// 延迟启动空闲加载
this.idleTimer = setTimeout(() => {
this.idleTimer = null;
loadNext();
}, IDLE_LOAD_DELAY);
}
/**
* 暂停空闲加载
*/
pauseIdleLoading() {
this.idlePaused = true;
this.cancelIdleLoading();
}
/**
* 恢复空闲加载
*/
resumeIdleLoading() {
this.idlePaused = false;
if (this.state.hasMore) {
this.startIdleLoading();
}
}
/**
* 取消空闲加载
*/
cancelIdleLoading() {
if (this.idleTimer) {
if (typeof cancelIdleCallback !== 'undefined') {
cancelIdleCallback(this.idleTimer);
} else {
clearTimeout(this.idleTimer);
}
this.idleTimer = null;
}
this.updateState({ isIdleLoading: false });
}
/**
* 异步保存到缓存(不阻塞主流程)
*/
async saveToCacheAsync(libraryId, folder, images) {
try {
const metaResponse = await imageAPI.getCacheMeta(libraryId);
const dbModifiedAt = metaResponse.data.dbModifiedAt;
await cacheService.saveFolderCache(libraryId, folder, images, dbModifiedAt);
console.log(`💾 Cached ${images.length} images for folder: ${folder || 'all'}`);
} catch (error) {
console.warn('Failed to save cache:', error);
}
}
/**
* 获取当前加载状态
*/
getState() {
return { ...this.state };
}
}
// 单例实例
const imageLoadService = new ImageLoadService();
export default imageLoadService;
export { ImageLoadService, DEFAULT_BATCH_SIZE };
@@ -0,0 +1,230 @@
/**
* ImageLoadService 属性测试
*
* **Feature: library-switch-optimization, Property 4: Scroll triggers batch loading**
* **Feature: library-switch-optimization, Property 11: Batch loading updates display incrementally**
* **Validates: Requirements 2.3, 5.2**
*/
import { describe, it, expect, beforeEach, vi } from 'vitest';
import * as fc from 'fast-check';
import { ImageLoadService, DEFAULT_BATCH_SIZE } from './imageLoadService.js';
// Mock dependencies
vi.mock('./api', () => ({
imageAPI: {
search: vi.fn(),
getCacheMeta: vi.fn()
}
}));
vi.mock('./cacheService', () => ({
default: {
getFolderCache: vi.fn().mockResolvedValue(null),
saveFolderCache: vi.fn().mockResolvedValue(undefined),
invalidateFolder: vi.fn().mockResolvedValue(undefined)
}
}));
vi.mock('./requestManager', () => ({
default: {
createRequest: vi.fn(() => ({
id: `req_${Date.now()}`,
signal: new AbortController().signal,
isActive: true
})),
cancelAll: vi.fn(),
isValid: vi.fn().mockReturnValue(true),
complete: vi.fn(),
error: vi.fn()
},
RequestType: {
LIBRARY: 'library',
FOLDER: 'folder',
IMAGES: 'images'
}
}));
describe('ImageLoadService', () => {
let service;
beforeEach(() => {
service = new ImageLoadService();
vi.clearAllMocks();
});
/**
* **Property 4: Scroll triggers batch loading**
* *For any* folder with more images than the initial batch size,
* scrolling to the bottom should trigger loading of the next batch.
*/
describe('Property 4: Scroll triggers batch loading', () => {
it('should set hasMore=true when total exceeds loaded count', () => {
fc.assert(
fc.property(
fc.integer({ min: DEFAULT_BATCH_SIZE + 1, max: 10000 }),
(totalImages) => {
// 模拟状态:已加载一批,还有更多
service.updateState({
images: Array(DEFAULT_BATCH_SIZE).fill({ id: 1 }),
offset: DEFAULT_BATCH_SIZE,
total: totalImages,
hasMore: true
});
return service.state.hasMore === true &&
service.state.offset < service.state.total;
}
),
{ numRuns: 100 }
);
});
it('should set hasMore=false when all images loaded', () => {
fc.assert(
fc.property(
fc.integer({ min: 1, max: DEFAULT_BATCH_SIZE }),
(totalImages) => {
// 模拟状态:所有图片已加载
service.updateState({
images: Array(totalImages).fill({ id: 1 }),
offset: totalImages,
total: totalImages,
hasMore: false
});
return service.state.hasMore === false &&
service.state.offset === service.state.total;
}
),
{ numRuns: 100 }
);
});
});
/**
* **Property 11: Batch loading updates display incrementally**
* *For any* batch load completion, the displayed image count should
* increase by the batch size (or remaining count if less).
*/
describe('Property 11: Batch loading updates display incrementally', () => {
it('should increment image count by batch size', () => {
fc.assert(
fc.property(
fc.integer({ min: 0, max: 5000 }),
fc.integer({ min: 1, max: DEFAULT_BATCH_SIZE }),
(initialCount, batchSize) => {
const initialImages = Array(initialCount).fill({ id: 1 });
const newImages = Array(batchSize).fill({ id: 2 });
service.updateState({
images: initialImages,
offset: initialCount
});
const prevCount = service.state.images.length;
// 模拟追加新批次
service.updateState({
images: [...initialImages, ...newImages],
offset: initialCount + batchSize
});
const newCount = service.state.images.length;
return newCount === prevCount + batchSize;
}
),
{ numRuns: 100 }
);
});
it('should handle partial batch at end', () => {
fc.assert(
fc.property(
fc.integer({ min: 1, max: DEFAULT_BATCH_SIZE - 1 }),
(remainingCount) => {
const total = DEFAULT_BATCH_SIZE + remainingCount;
const initialImages = Array(DEFAULT_BATCH_SIZE).fill({ id: 1 });
const remainingImages = Array(remainingCount).fill({ id: 2 });
service.updateState({
images: initialImages,
offset: DEFAULT_BATCH_SIZE,
total,
hasMore: true
});
// 模拟加载最后一批(不足一个完整批次)
service.updateState({
images: [...initialImages, ...remainingImages],
offset: total,
total,
hasMore: false
});
return service.state.images.length === total &&
service.state.hasMore === false;
}
),
{ numRuns: 100 }
);
});
});
describe('State management', () => {
it('should reset state correctly', () => {
service.updateState({
libraryId: 'test',
folder: 'folder',
images: [{ id: 1 }],
offset: 100,
total: 1000,
hasMore: true,
isLoading: true
});
service.reset();
expect(service.state.libraryId).toBe(null);
expect(service.state.folder).toBe(null);
expect(service.state.images).toHaveLength(0);
expect(service.state.offset).toBe(0);
expect(service.state.total).toBe(0);
expect(service.state.hasMore).toBe(false);
expect(service.state.isLoading).toBe(false);
});
it('should notify on state change', () => {
const callback = vi.fn();
service.setOnStateChange(callback);
service.updateState({ isLoading: true });
expect(callback).toHaveBeenCalledWith(expect.objectContaining({
isLoading: true
}));
});
});
describe('Idle loading control', () => {
it('should pause and resume idle loading', () => {
service.updateState({ hasMore: true, isIdleLoading: true });
service.pauseIdleLoading();
expect(service.idlePaused).toBe(true);
service.resumeIdleLoading();
expect(service.idlePaused).toBe(false);
});
it('should cancel idle loading', () => {
service.idleTimer = setTimeout(() => {}, 10000);
service.updateState({ isIdleLoading: true });
service.cancelIdleLoading();
expect(service.idleTimer).toBe(null);
expect(service.state.isIdleLoading).toBe(false);
});
});
});
+166
View File
@@ -0,0 +1,166 @@
/**
* RequestManager - 统一管理异步请求的生命周期
* 支持请求取消、去重、竞态条件处理
*/
// 请求类型
export const RequestType = {
LIBRARY: 'library',
FOLDER: 'folder',
IMAGES: 'images'
};
// 生成唯一 ID
let requestIdCounter = 0;
const generateRequestId = () => {
requestIdCounter += 1;
return `req_${Date.now()}_${requestIdCounter}`;
};
class RequestManager {
constructor() {
// 按类型存储活跃的请求
this.activeRequests = new Map();
// 存储所有请求上下文
this.requestContexts = new Map();
}
/**
* 创建一个新的请求上下文
* @param {string} type - 请求类型 (library/folder/images)
* @returns {RequestContext}
*/
createRequest(type) {
const id = generateRequestId();
const abortController = new AbortController();
const context = {
id,
type,
createdAt: Date.now(),
abortController,
signal: abortController.signal,
status: 'pending',
isActive: true,
cancel: () => {
if (context.isActive) {
context.isActive = false;
context.status = 'cancelled';
abortController.abort();
this.requestContexts.delete(id);
// 从活跃请求中移除
const typeRequests = this.activeRequests.get(type);
if (typeRequests) {
typeRequests.delete(id);
}
}
}
};
// 存储请求上下文
this.requestContexts.set(id, context);
// 添加到活跃请求
if (!this.activeRequests.has(type)) {
this.activeRequests.set(type, new Map());
}
this.activeRequests.get(type).set(id, context);
return context;
}
/**
* 取消指定类型的所有请求
* @param {string} type - 请求类型
*/
cancelAll(type) {
const typeRequests = this.activeRequests.get(type);
if (typeRequests) {
for (const context of typeRequests.values()) {
context.cancel();
}
typeRequests.clear();
}
}
/**
* 取消所有请求
*/
cancelAllRequests() {
for (const type of Object.values(RequestType)) {
this.cancelAll(type);
}
}
/**
* 检查请求是否仍然有效(未被取消)
* @param {string} requestId - 请求 ID
* @returns {boolean}
*/
isValid(requestId) {
const context = this.requestContexts.get(requestId);
return context ? context.isActive : false;
}
/**
* 标记请求完成
* @param {string} requestId - 请求 ID
*/
complete(requestId) {
const context = this.requestContexts.get(requestId);
if (context && context.isActive) {
context.status = 'completed';
context.isActive = false;
this.requestContexts.delete(requestId);
const typeRequests = this.activeRequests.get(context.type);
if (typeRequests) {
typeRequests.delete(requestId);
}
}
}
/**
* 标记请求错误
* @param {string} requestId - 请求 ID
*/
error(requestId) {
const context = this.requestContexts.get(requestId);
if (context && context.isActive) {
context.status = 'error';
context.isActive = false;
this.requestContexts.delete(requestId);
const typeRequests = this.activeRequests.get(context.type);
if (typeRequests) {
typeRequests.delete(requestId);
}
}
}
/**
* 获取指定类型的活跃请求数量
* @param {string} type - 请求类型
* @returns {number}
*/
getActiveCount(type) {
const typeRequests = this.activeRequests.get(type);
return typeRequests ? typeRequests.size : 0;
}
/**
* 检查是否有指定类型的活跃请求
* @param {string} type - 请求类型
* @returns {boolean}
*/
hasActiveRequests(type) {
return this.getActiveCount(type) > 0;
}
}
// 单例实例
const requestManager = new RequestManager();
export default requestManager;
export { RequestManager };
@@ -0,0 +1,232 @@
/**
* RequestManager 属性测试
* 使用 fast-check 进行属性测试
*/
import { describe, it, expect, beforeEach } from 'vitest';
import * as fc from 'fast-check';
import { RequestManager, RequestType } from './requestManager.js';
describe('RequestManager', () => {
let manager;
beforeEach(() => {
manager = new RequestManager();
});
/**
* **Feature: library-switch-optimization, Property 7: Unique request IDs**
* *For any* set of requests created by RequestManager, each request should have
* a unique ID that is different from all other request IDs.
* **Validates: Requirements 4.1**
*/
describe('Property 7: Unique request IDs', () => {
it('should generate unique IDs for all requests', () => {
fc.assert(
fc.property(
fc.integer({ min: 1, max: 100 }),
(requestCount) => {
const localManager = new RequestManager();
const ids = new Set();
for (let i = 0; i < requestCount; i++) {
const type = Object.values(RequestType)[i % 3];
const context = localManager.createRequest(type);
ids.add(context.id);
}
// 所有 ID 应该唯一
return ids.size === requestCount;
}
),
{ numRuns: 100 }
);
});
it('should generate unique IDs across different request types', () => {
fc.assert(
fc.property(
fc.array(fc.constantFrom(...Object.values(RequestType)), { minLength: 1, maxLength: 50 }),
(types) => {
const localManager = new RequestManager();
const ids = new Set();
for (const type of types) {
const context = localManager.createRequest(type);
ids.add(context.id);
}
return ids.size === types.length;
}
),
{ numRuns: 100 }
);
});
});
/**
* **Feature: library-switch-optimization, Property 8: Cancelled requests don't trigger callbacks**
* *For any* cancelled request, its completion callback should not be executed,
* and its result should not be applied to the state.
* **Validates: Requirements 4.2**
*/
describe('Property 8: Cancelled requests don\'t trigger callbacks', () => {
it('should mark cancelled requests as inactive', () => {
fc.assert(
fc.property(
fc.constantFrom(...Object.values(RequestType)),
(type) => {
const context = manager.createRequest(type);
const requestId = context.id;
// 请求应该是活跃的
expect(manager.isValid(requestId)).toBe(true);
expect(context.isActive).toBe(true);
// 取消请求
context.cancel();
// 请求应该不再有效
expect(manager.isValid(requestId)).toBe(false);
expect(context.isActive).toBe(false);
expect(context.status).toBe('cancelled');
return true;
}
),
{ numRuns: 100 }
);
});
it('should abort the AbortController signal when cancelled', () => {
fc.assert(
fc.property(
fc.constantFrom(...Object.values(RequestType)),
(type) => {
const context = manager.createRequest(type);
expect(context.signal.aborted).toBe(false);
context.cancel();
expect(context.signal.aborted).toBe(true);
return true;
}
),
{ numRuns: 100 }
);
});
it('should remove cancelled requests from active requests', () => {
fc.assert(
fc.property(
fc.constantFrom(...Object.values(RequestType)),
fc.integer({ min: 1, max: 10 }),
(type, count) => {
const localManager = new RequestManager();
const contexts = [];
// 创建多个请求
for (let i = 0; i < count; i++) {
contexts.push(localManager.createRequest(type));
}
expect(localManager.getActiveCount(type)).toBe(count);
// 取消所有请求
for (const ctx of contexts) {
ctx.cancel();
}
expect(localManager.getActiveCount(type)).toBe(0);
return true;
}
),
{ numRuns: 100 }
);
});
it('cancelAll should cancel all requests of a specific type', () => {
fc.assert(
fc.property(
fc.integer({ min: 1, max: 20 }),
(count) => {
const localManager = new RequestManager();
const contexts = [];
// 创建多个 FOLDER 类型请求
for (let i = 0; i < count; i++) {
contexts.push(localManager.createRequest(RequestType.FOLDER));
}
// 创建一个 LIBRARY 类型请求
const libraryContext = localManager.createRequest(RequestType.LIBRARY);
expect(localManager.getActiveCount(RequestType.FOLDER)).toBe(count);
expect(localManager.getActiveCount(RequestType.LIBRARY)).toBe(1);
// 取消所有 FOLDER 请求
localManager.cancelAll(RequestType.FOLDER);
// FOLDER 请求应该全部取消
expect(localManager.getActiveCount(RequestType.FOLDER)).toBe(0);
for (const ctx of contexts) {
expect(ctx.isActive).toBe(false);
expect(ctx.signal.aborted).toBe(true);
}
// LIBRARY 请求应该不受影响
expect(localManager.getActiveCount(RequestType.LIBRARY)).toBe(1);
expect(libraryContext.isActive).toBe(true);
return true;
}
),
{ numRuns: 100 }
);
});
});
describe('Request lifecycle', () => {
it('should properly track request completion', () => {
const context = manager.createRequest(RequestType.IMAGES);
const requestId = context.id;
expect(manager.isValid(requestId)).toBe(true);
manager.complete(requestId);
expect(manager.isValid(requestId)).toBe(false);
expect(context.status).toBe('completed');
});
it('should properly track request errors', () => {
const context = manager.createRequest(RequestType.IMAGES);
const requestId = context.id;
expect(manager.isValid(requestId)).toBe(true);
manager.error(requestId);
expect(manager.isValid(requestId)).toBe(false);
expect(context.status).toBe('error');
});
it('cancelAllRequests should cancel all types', () => {
manager.createRequest(RequestType.LIBRARY);
manager.createRequest(RequestType.FOLDER);
manager.createRequest(RequestType.IMAGES);
expect(manager.hasActiveRequests(RequestType.LIBRARY)).toBe(true);
expect(manager.hasActiveRequests(RequestType.FOLDER)).toBe(true);
expect(manager.hasActiveRequests(RequestType.IMAGES)).toBe(true);
manager.cancelAllRequests();
expect(manager.hasActiveRequests(RequestType.LIBRARY)).toBe(false);
expect(manager.hasActiveRequests(RequestType.FOLDER)).toBe(false);
expect(manager.hasActiveRequests(RequestType.IMAGES)).toBe(false);
});
});
});
+19
View File
@@ -24,6 +24,25 @@ const useStore = create((set, get) => ({
setImages: (images) => set({ images, filteredImages: images }),
setFilteredImages: (filteredImages) => set({ filteredImages }),
setTotalImageCount: (count) => set({ totalImageCount: count }),
// 图片加载状态(用于分批加载)
imageLoadingState: {
isLoading: false,
isIdleLoading: false,
loadedCount: 0,
totalCount: 0,
hasMore: false,
currentRequestId: null
},
setImageLoadingState: (state) => set((prev) => ({
imageLoadingState: { ...prev.imageLoadingState, ...state }
})),
// 追加图片(用于分批加载)
appendImages: (newImages) => set((state) => ({
images: [...state.images, ...newImages],
filteredImages: [...state.filteredImages, ...newImages]
})),
// Folders
folders: [],
+210 -37
View File
@@ -1,30 +1,76 @@
/**
* 瀑布流布局计算 Worker
* 将耗时的布局计算移到后台线程,避免阻塞主线程
*
* 优化策略:
* 1. 支持增量计算 - 只计算新增图片的布局
* 2. 只传输必要字段 - 减少数据传输开销
* 3. 分块处理 - 避免长时间阻塞 Worker 线程
*/
const GAP = 16;
// 缓存上次计算的状态,用于增量计算
let cachedState = {
containerWidth: 0,
targetHeight: 0,
imageCount: 0,
rows: [],
// 最后一行的未完成状态(用于增量追加)
pendingRow: [],
pendingRowWidthSum: 0
};
/**
* 计算瀑布流布局
* @param {Array} images - 图片列表
* 计算单行布局
* @param {Array} rowImages - 行内图片
* @param {number} containerWidth - 容器宽度
* @param {number} rowWidthSum - 行内图片原始宽度总和
* @param {boolean} isLastRow - 是否是最后一行
* @param {number} targetHeight - 目标行高
* @returns {Array} 计算后的行
*/
function finalizeRow(rowImages, containerWidth, rowWidthSum, isLastRow, targetHeight) {
const totalGaps = (rowImages.length - 1) * GAP;
const availableWidth = containerWidth - totalGaps;
let scale = availableWidth / rowWidthSum;
// 最后一行少于3张图片时,限制拉伸
if (isLastRow && rowImages.length < 3) {
scale = Math.min(scale, 1.2);
}
const rowHeight = targetHeight * scale;
return rowImages.map(img => ({
...img,
calculatedWidth: img.originalWidth * scale,
calculatedHeight: rowHeight
}));
}
/**
* 计算瀑布流布局(完整计算)
* @param {Array} images - 图片列表(只包含必要字段)
* @param {number} containerWidth - 容器宽度
* @param {number} targetHeight - 目标行高
* @returns {Array} 计算后的行数组
* @returns {Object} { rows, pendingRow, pendingRowWidthSum }
*/
function calculateLayout(images, containerWidth, targetHeight) {
function calculateLayoutFull(images, containerWidth, targetHeight) {
if (!images.length || !containerWidth) {
return [];
return { rows: [], pendingRow: [], pendingRowWidthSum: 0 };
}
const gap = 16;
const calculatedRows = [];
let currentRow = [];
let currentRowWidthSum = 0;
images.forEach((image, index) => {
for (let index = 0; index < images.length; index++) {
const image = images[index];
const aspectRatio = image.width / image.height;
const imageWidth = targetHeight * aspectRatio;
// Add to current row
currentRow.push({
...image,
originalWidth: imageWidth,
@@ -32,12 +78,10 @@ function calculateLayout(images, containerWidth, targetHeight) {
});
currentRowWidthSum += imageWidth;
// Calculate if current row is ready to be finalized
const currentGaps = (currentRow.length - 1) * gap;
const currentGaps = (currentRow.length - 1) * GAP;
const totalWidth = currentRowWidthSum + currentGaps;
const isLastImage = index === images.length - 1;
// Decide if we should finish this row
let shouldFinishRow = false;
if (isLastImage) {
@@ -49,7 +93,7 @@ function calculateLayout(images, containerWidth, targetHeight) {
if (nextImage) {
const nextAspectRatio = nextImage.width / nextImage.height;
const nextImageWidth = targetHeight * nextAspectRatio;
const nextTotalWidth = currentRowWidthSum + nextImageWidth + (currentRow.length * gap);
const nextTotalWidth = currentRowWidthSum + nextImageWidth + (currentRow.length * GAP);
if (nextTotalWidth > containerWidth * 1.2) {
shouldFinishRow = true;
@@ -58,47 +102,176 @@ function calculateLayout(images, containerWidth, targetHeight) {
}
if (shouldFinishRow) {
const totalGaps = (currentRow.length - 1) * gap;
const availableWidth = containerWidth - totalGaps;
let scale = availableWidth / currentRowWidthSum;
if (isLastImage && currentRow.length < 3) {
scale = Math.min(scale, 1.2);
}
const rowHeight = targetHeight * scale;
currentRow = currentRow.map(img => ({
...img,
calculatedWidth: img.originalWidth * scale,
calculatedHeight: rowHeight
}));
calculatedRows.push(currentRow);
const finalizedRow = finalizeRow(currentRow, containerWidth, currentRowWidthSum, isLastImage, targetHeight);
calculatedRows.push(finalizedRow);
currentRow = [];
currentRowWidthSum = 0;
}
});
}
return calculatedRows;
return {
rows: calculatedRows,
pendingRow: currentRow,
pendingRowWidthSum: currentRowWidthSum
};
}
/**
* 增量计算布局 - 只处理新增的图片
* @param {Array} newImages - 新增的图片列表
* @param {number} containerWidth - 容器宽度
* @param {number} targetHeight - 目标行高
* @param {Array} existingRows - 已有的行(不含最后一行)
* @param {Array} pendingRow - 上次未完成的行
* @param {number} pendingRowWidthSum - 上次未完成行的宽度和
* @returns {Object} { rows, pendingRow, pendingRowWidthSum }
*/
function calculateLayoutIncremental(newImages, containerWidth, targetHeight, existingRows, pendingRow, pendingRowWidthSum) {
if (!newImages.length) {
// 没有新图片,只需要重新计算最后一行
if (pendingRow.length > 0) {
const finalizedRow = finalizeRow(pendingRow, containerWidth, pendingRowWidthSum, true, targetHeight);
return {
rows: [...existingRows, finalizedRow],
pendingRow: [],
pendingRowWidthSum: 0
};
}
return { rows: existingRows, pendingRow: [], pendingRowWidthSum: 0 };
}
const calculatedRows = [...existingRows];
let currentRow = [...pendingRow];
let currentRowWidthSum = pendingRowWidthSum;
// 合并所有图片(包括 pending 的)来计算总数
const totalImageCount = existingRows.reduce((sum, row) => sum + row.length, 0) + pendingRow.length + newImages.length;
for (let i = 0; i < newImages.length; i++) {
const image = newImages[i];
const aspectRatio = image.width / image.height;
const imageWidth = targetHeight * aspectRatio;
currentRow.push({
...image,
originalWidth: imageWidth,
aspectRatio: aspectRatio
});
currentRowWidthSum += imageWidth;
const currentGaps = (currentRow.length - 1) * GAP;
const totalWidth = currentRowWidthSum + currentGaps;
const processedCount = existingRows.reduce((sum, row) => sum + row.length, 0) + calculatedRows.length - existingRows.length + currentRow.length;
const isLastImage = processedCount >= totalImageCount;
let shouldFinishRow = false;
if (isLastImage) {
shouldFinishRow = true;
} else if (totalWidth >= containerWidth * 0.95) {
shouldFinishRow = true;
} else {
const nextImage = newImages[i + 1];
if (nextImage) {
const nextAspectRatio = nextImage.width / nextImage.height;
const nextImageWidth = targetHeight * nextAspectRatio;
const nextTotalWidth = currentRowWidthSum + nextImageWidth + (currentRow.length * GAP);
if (nextTotalWidth > containerWidth * 1.2) {
shouldFinishRow = true;
}
}
}
if (shouldFinishRow) {
const finalizedRow = finalizeRow(currentRow, containerWidth, currentRowWidthSum, isLastImage, targetHeight);
calculatedRows.push(finalizedRow);
currentRow = [];
currentRowWidthSum = 0;
}
}
return {
rows: calculatedRows,
pendingRow: currentRow,
pendingRowWidthSum: currentRowWidthSum
};
}
/**
* 重置缓存状态
*/
function resetCache() {
cachedState = {
containerWidth: 0,
targetHeight: 0,
imageCount: 0,
rows: [],
pendingRow: [],
pendingRowWidthSum: 0
};
}
// 监听主线程消息
self.onmessage = function(e) {
const { images, containerWidth, targetHeight, requestId } = e.data;
const { images, containerWidth, targetHeight, requestId, incremental, reset } = e.data;
// 显式重置请求
if (reset) {
resetCache();
self.postMessage({ requestId, reset: true });
return;
}
const startTime = performance.now();
const rows = calculateLayout(images, containerWidth, targetHeight);
let result;
// 判断是否可以使用增量计算
const canUseIncremental = incremental &&
cachedState.containerWidth === containerWidth &&
cachedState.targetHeight === targetHeight &&
images.length > cachedState.imageCount;
if (canUseIncremental) {
// 增量计算:只处理新增的图片
const newImages = images.slice(cachedState.imageCount);
// 移除最后一行(因为它可能是未完成的)
const existingRows = cachedState.rows.slice(0, -1);
const lastRow = cachedState.rows[cachedState.rows.length - 1] || [];
result = calculateLayoutIncremental(
newImages,
containerWidth,
targetHeight,
existingRows,
cachedState.pendingRow.length > 0 ? cachedState.pendingRow : lastRow,
cachedState.pendingRowWidthSum > 0 ? cachedState.pendingRowWidthSum : lastRow.reduce((sum, img) => sum + img.originalWidth, 0)
);
} else {
// 完整计算
result = calculateLayoutFull(images, containerWidth, targetHeight);
}
// 更新缓存
cachedState = {
containerWidth,
targetHeight,
imageCount: images.length,
rows: result.rows,
pendingRow: result.pendingRow,
pendingRowWidthSum: result.pendingRowWidthSum
};
const duration = performance.now() - startTime;
// 返回结果
self.postMessage({
rows,
rows: result.rows,
requestId,
duration,
imageCount: images.length,
rowCount: rows.length
rowCount: result.rows.length,
incremental: canUseIncremental
});
};
+9
View File
@@ -0,0 +1,9 @@
import { defineConfig } from 'vitest/config';
export default defineConfig({
test: {
environment: 'node',
include: ['src/**/*.test.js'],
globals: true
}
});
+738 -1
View File
@@ -53,9 +53,11 @@
"@types/react-dom": "^18.2.17",
"@vitejs/plugin-react": "^4.2.1",
"autoprefixer": "^10.4.16",
"fast-check": "^3.15.0",
"postcss": "^8.4.32",
"tailwindcss": "^3.4.0",
"vite": "^5.0.8"
"vite": "^5.0.8",
"vitest": "^1.2.0"
}
},
"node_modules/@alloc/quick-lru": {
@@ -1155,6 +1157,19 @@
"node": ">=12"
}
},
"node_modules/@jest/schemas": {
"version": "29.6.3",
"resolved": "https://registry.npmmirror.com/@jest/schemas/-/schemas-29.6.3.tgz",
"integrity": "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==",
"dev": true,
"license": "MIT",
"dependencies": {
"@sinclair/typebox": "^0.27.8"
},
"engines": {
"node": "^14.15.0 || ^16.10.0 || >=18.0.0"
}
},
"node_modules/@jridgewell/gen-mapping": {
"version": "0.3.13",
"resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
@@ -1529,6 +1544,13 @@
"win32"
]
},
"node_modules/@sinclair/typebox": {
"version": "0.27.8",
"resolved": "https://registry.npmmirror.com/@sinclair/typebox/-/typebox-0.27.8.tgz",
"integrity": "sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==",
"dev": true,
"license": "MIT"
},
"node_modules/@socket.io/component-emitter": {
"version": "3.1.2",
"resolved": "https://registry.npmmirror.com/@socket.io/component-emitter/-/component-emitter-3.1.2.tgz",
@@ -1654,6 +1676,96 @@
"vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
}
},
"node_modules/@vitest/expect": {
"version": "1.6.1",
"resolved": "https://registry.npmmirror.com/@vitest/expect/-/expect-1.6.1.tgz",
"integrity": "sha512-jXL+9+ZNIJKruofqXuuTClf44eSpcHlgj3CiuNihUF3Ioujtmc0zIa3UJOW5RjDK1YLBJZnWBlPuqhYycLioog==",
"dev": true,
"license": "MIT",
"dependencies": {
"@vitest/spy": "1.6.1",
"@vitest/utils": "1.6.1",
"chai": "^4.3.10"
},
"funding": {
"url": "https://opencollective.com/vitest"
}
},
"node_modules/@vitest/runner": {
"version": "1.6.1",
"resolved": "https://registry.npmmirror.com/@vitest/runner/-/runner-1.6.1.tgz",
"integrity": "sha512-3nSnYXkVkf3mXFfE7vVyPmi3Sazhb/2cfZGGs0JRzFsPFvAMBEcrweV1V1GsrstdXeKCTXlJbvnQwGWgEIHmOA==",
"dev": true,
"license": "MIT",
"dependencies": {
"@vitest/utils": "1.6.1",
"p-limit": "^5.0.0",
"pathe": "^1.1.1"
},
"funding": {
"url": "https://opencollective.com/vitest"
}
},
"node_modules/@vitest/runner/node_modules/p-limit": {
"version": "5.0.0",
"resolved": "https://registry.npmmirror.com/p-limit/-/p-limit-5.0.0.tgz",
"integrity": "sha512-/Eaoq+QyLSiXQ4lyYV23f14mZRQcXnxfHrN0vCai+ak9G0pp9iEQukIIZq5NccEvwRB8PUnZT0KsOoDCINS1qQ==",
"dev": true,
"license": "MIT",
"dependencies": {
"yocto-queue": "^1.0.0"
},
"engines": {
"node": ">=18"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/@vitest/snapshot": {
"version": "1.6.1",
"resolved": "https://registry.npmmirror.com/@vitest/snapshot/-/snapshot-1.6.1.tgz",
"integrity": "sha512-WvidQuWAzU2p95u8GAKlRMqMyN1yOJkGHnx3M1PL9Raf7AQ1kwLKg04ADlCa3+OXUZE7BceOhVZiuWAbzCKcUQ==",
"dev": true,
"license": "MIT",
"dependencies": {
"magic-string": "^0.30.5",
"pathe": "^1.1.1",
"pretty-format": "^29.7.0"
},
"funding": {
"url": "https://opencollective.com/vitest"
}
},
"node_modules/@vitest/spy": {
"version": "1.6.1",
"resolved": "https://registry.npmmirror.com/@vitest/spy/-/spy-1.6.1.tgz",
"integrity": "sha512-MGcMmpGkZebsMZhbQKkAf9CX5zGvjkBTqf8Zx3ApYWXr3wG+QvEu2eXWfnIIWYSJExIp4V9FCKDEeygzkYrXMw==",
"dev": true,
"license": "MIT",
"dependencies": {
"tinyspy": "^2.2.0"
},
"funding": {
"url": "https://opencollective.com/vitest"
}
},
"node_modules/@vitest/utils": {
"version": "1.6.1",
"resolved": "https://registry.npmmirror.com/@vitest/utils/-/utils-1.6.1.tgz",
"integrity": "sha512-jOrrUvXM4Av9ZWiG1EajNto0u96kWAhJ1LmPmJhXXQx/32MecEKd10pOLYgS2BQx1TgkGhloPU1ArDW2vvaY6g==",
"dev": true,
"license": "MIT",
"dependencies": {
"diff-sequences": "^29.6.3",
"estree-walker": "^3.0.3",
"loupe": "^2.3.7",
"pretty-format": "^29.7.0"
},
"funding": {
"url": "https://opencollective.com/vitest"
}
},
"node_modules/accepts": {
"version": "1.3.8",
"resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
@@ -1667,6 +1779,32 @@
"node": ">= 0.6"
}
},
"node_modules/acorn": {
"version": "8.15.0",
"resolved": "https://registry.npmmirror.com/acorn/-/acorn-8.15.0.tgz",
"integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
"dev": true,
"license": "MIT",
"bin": {
"acorn": "bin/acorn"
},
"engines": {
"node": ">=0.4.0"
}
},
"node_modules/acorn-walk": {
"version": "8.3.4",
"resolved": "https://registry.npmmirror.com/acorn-walk/-/acorn-walk-8.3.4.tgz",
"integrity": "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==",
"dev": true,
"license": "MIT",
"dependencies": {
"acorn": "^8.11.0"
},
"engines": {
"node": ">=0.4.0"
}
},
"node_modules/ansi-regex": {
"version": "6.2.2",
"resolved": "https://registry.npmmirror.com/ansi-regex/-/ansi-regex-6.2.2.tgz",
@@ -1724,6 +1862,16 @@
"integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
"license": "MIT"
},
"node_modules/assertion-error": {
"version": "1.1.0",
"resolved": "https://registry.npmmirror.com/assertion-error/-/assertion-error-1.1.0.tgz",
"integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==",
"dev": true,
"license": "MIT",
"engines": {
"node": "*"
}
},
"node_modules/asynckit": {
"version": "0.4.0",
"resolved": "https://registry.npmmirror.com/asynckit/-/asynckit-0.4.0.tgz",
@@ -1994,6 +2142,16 @@
"node": ">= 0.8"
}
},
"node_modules/cac": {
"version": "6.7.14",
"resolved": "https://registry.npmmirror.com/cac/-/cac-6.7.14.tgz",
"integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
"dev": true,
"license": "MIT",
"engines": {
"node": ">=8"
}
},
"node_modules/call-bind-apply-helpers": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
@@ -2054,6 +2212,38 @@
],
"license": "CC-BY-4.0"
},
"node_modules/chai": {
"version": "4.5.0",
"resolved": "https://registry.npmmirror.com/chai/-/chai-4.5.0.tgz",
"integrity": "sha512-RITGBfijLkBddZvnn8jdqoTypxvqbOLYQkGGxXzeFjVHvudaPw0HNFD9x928/eUwYWd2dPCugVqspGALTZZQKw==",
"dev": true,
"license": "MIT",
"dependencies": {
"assertion-error": "^1.1.0",
"check-error": "^1.0.3",
"deep-eql": "^4.1.3",
"get-func-name": "^2.0.2",
"loupe": "^2.3.6",
"pathval": "^1.1.1",
"type-detect": "^4.1.0"
},
"engines": {
"node": ">=4"
}
},
"node_modules/check-error": {
"version": "1.0.3",
"resolved": "https://registry.npmmirror.com/check-error/-/check-error-1.0.3.tgz",
"integrity": "sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==",
"dev": true,
"license": "MIT",
"dependencies": {
"get-func-name": "^2.0.2"
},
"engines": {
"node": "*"
}
},
"node_modules/chokidar": {
"version": "3.6.0",
"resolved": "https://registry.npmmirror.com/chokidar/-/chokidar-3.6.0.tgz",
@@ -2154,6 +2344,13 @@
"dev": true,
"license": "MIT"
},
"node_modules/confbox": {
"version": "0.1.8",
"resolved": "https://registry.npmmirror.com/confbox/-/confbox-0.1.8.tgz",
"integrity": "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==",
"dev": true,
"license": "MIT"
},
"node_modules/content-disposition": {
"version": "0.5.4",
"resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
@@ -2309,6 +2506,19 @@
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/deep-eql": {
"version": "4.1.4",
"resolved": "https://registry.npmmirror.com/deep-eql/-/deep-eql-4.1.4.tgz",
"integrity": "sha512-SUwdGfqdKOwxCPeVYjwSyRpJ7Z+fhpwIAtmCUdZIWZ/YP5R9WAsyuSgpLVDi9bjWoN2LXHNss/dk3urXtdQxGg==",
"dev": true,
"license": "MIT",
"dependencies": {
"type-detect": "^4.0.0"
},
"engines": {
"node": ">=6"
}
},
"node_modules/deep-extend": {
"version": "0.6.0",
"resolved": "https://registry.npmmirror.com/deep-extend/-/deep-extend-0.6.0.tgz",
@@ -2362,6 +2572,16 @@
"dev": true,
"license": "Apache-2.0"
},
"node_modules/diff-sequences": {
"version": "29.6.3",
"resolved": "https://registry.npmmirror.com/diff-sequences/-/diff-sequences-29.6.3.tgz",
"integrity": "sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==",
"dev": true,
"license": "MIT",
"engines": {
"node": "^14.15.0 || ^16.10.0 || >=18.0.0"
}
},
"node_modules/dlv": {
"version": "1.1.3",
"resolved": "https://registry.npmmirror.com/dlv/-/dlv-1.1.3.tgz",
@@ -2611,6 +2831,16 @@
"integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
"license": "MIT"
},
"node_modules/estree-walker": {
"version": "3.0.3",
"resolved": "https://registry.npmmirror.com/estree-walker/-/estree-walker-3.0.3.tgz",
"integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
"dev": true,
"license": "MIT",
"dependencies": {
"@types/estree": "^1.0.0"
}
},
"node_modules/etag": {
"version": "1.8.1",
"resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
@@ -2620,6 +2850,30 @@
"node": ">= 0.6"
}
},
"node_modules/execa": {
"version": "8.0.1",
"resolved": "https://registry.npmmirror.com/execa/-/execa-8.0.1.tgz",
"integrity": "sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==",
"dev": true,
"license": "MIT",
"dependencies": {
"cross-spawn": "^7.0.3",
"get-stream": "^8.0.1",
"human-signals": "^5.0.0",
"is-stream": "^3.0.0",
"merge-stream": "^2.0.0",
"npm-run-path": "^5.1.0",
"onetime": "^6.0.0",
"signal-exit": "^4.1.0",
"strip-final-newline": "^3.0.0"
},
"engines": {
"node": ">=16.17"
},
"funding": {
"url": "https://github.com/sindresorhus/execa?sponsor=1"
}
},
"node_modules/expand-template": {
"version": "2.0.3",
"resolved": "https://registry.npmmirror.com/expand-template/-/expand-template-2.0.3.tgz",
@@ -2690,6 +2944,29 @@
"integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
"license": "MIT"
},
"node_modules/fast-check": {
"version": "3.23.2",
"resolved": "https://registry.npmmirror.com/fast-check/-/fast-check-3.23.2.tgz",
"integrity": "sha512-h5+1OzzfCC3Ef7VbtKdcv7zsstUQwUDlYpUTvjeUsJAssPgLn7QzbboPtL5ro04Mq0rPOsMzl7q5hIbRs2wD1A==",
"dev": true,
"funding": [
{
"type": "individual",
"url": "https://github.com/sponsors/dubzzz"
},
{
"type": "opencollective",
"url": "https://opencollective.com/fast-check"
}
],
"license": "MIT",
"dependencies": {
"pure-rand": "^6.1.0"
},
"engines": {
"node": ">=8.0.0"
}
},
"node_modules/fast-glob": {
"version": "3.3.3",
"resolved": "https://registry.npmmirror.com/fast-glob/-/fast-glob-3.3.3.tgz",
@@ -2899,6 +3176,16 @@
"node": ">=6.9.0"
}
},
"node_modules/get-func-name": {
"version": "2.0.2",
"resolved": "https://registry.npmmirror.com/get-func-name/-/get-func-name-2.0.2.tgz",
"integrity": "sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==",
"dev": true,
"license": "MIT",
"engines": {
"node": "*"
}
},
"node_modules/get-intrinsic": {
"version": "1.3.0",
"resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
@@ -2936,6 +3223,19 @@
"node": ">= 0.4"
}
},
"node_modules/get-stream": {
"version": "8.0.1",
"resolved": "https://registry.npmmirror.com/get-stream/-/get-stream-8.0.1.tgz",
"integrity": "sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==",
"dev": true,
"license": "MIT",
"engines": {
"node": ">=16"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/github-from-package": {
"version": "0.0.0",
"resolved": "https://registry.npmmirror.com/github-from-package/-/github-from-package-0.0.0.tgz",
@@ -3051,6 +3351,16 @@
"node": ">= 0.8"
}
},
"node_modules/human-signals": {
"version": "5.0.0",
"resolved": "https://registry.npmmirror.com/human-signals/-/human-signals-5.0.0.tgz",
"integrity": "sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==",
"dev": true,
"license": "Apache-2.0",
"engines": {
"node": ">=16.17.0"
}
},
"node_modules/iconv-lite": {
"version": "0.4.24",
"resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
@@ -3190,6 +3500,19 @@
"node": ">=0.12.0"
}
},
"node_modules/is-stream": {
"version": "3.0.0",
"resolved": "https://registry.npmmirror.com/is-stream/-/is-stream-3.0.0.tgz",
"integrity": "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==",
"dev": true,
"license": "MIT",
"engines": {
"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/isarray": {
"version": "1.0.0",
"resolved": "https://registry.npmmirror.com/isarray/-/isarray-1.0.0.tgz",
@@ -3330,6 +3653,23 @@
"dev": true,
"license": "MIT"
},
"node_modules/local-pkg": {
"version": "0.5.1",
"resolved": "https://registry.npmmirror.com/local-pkg/-/local-pkg-0.5.1.tgz",
"integrity": "sha512-9rrA30MRRP3gBD3HTGnC6cDFpaE1kVDWxWgqWJUN0RvDNAo+Nz/9GxB+nHOH0ifbVFy0hSA1V6vFDvnx54lTEQ==",
"dev": true,
"license": "MIT",
"dependencies": {
"mlly": "^1.7.3",
"pkg-types": "^1.2.1"
},
"engines": {
"node": ">=14"
},
"funding": {
"url": "https://github.com/sponsors/antfu"
}
},
"node_modules/loose-envify": {
"version": "1.4.0",
"resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
@@ -3342,6 +3682,16 @@
"loose-envify": "cli.js"
}
},
"node_modules/loupe": {
"version": "2.3.7",
"resolved": "https://registry.npmmirror.com/loupe/-/loupe-2.3.7.tgz",
"integrity": "sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==",
"dev": true,
"license": "MIT",
"dependencies": {
"get-func-name": "^2.0.1"
}
},
"node_modules/lru-cache": {
"version": "5.1.1",
"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
@@ -3361,6 +3711,16 @@
"react": "^16.5.1 || ^17.0.0 || ^18.0.0"
}
},
"node_modules/magic-string": {
"version": "0.30.21",
"resolved": "https://registry.npmmirror.com/magic-string/-/magic-string-0.30.21.tgz",
"integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
"dev": true,
"license": "MIT",
"dependencies": {
"@jridgewell/sourcemap-codec": "^1.5.5"
}
},
"node_modules/math-intrinsics": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
@@ -3394,6 +3754,13 @@
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/merge-stream": {
"version": "2.0.0",
"resolved": "https://registry.npmmirror.com/merge-stream/-/merge-stream-2.0.0.tgz",
"integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==",
"dev": true,
"license": "MIT"
},
"node_modules/merge2": {
"version": "1.4.1",
"resolved": "https://registry.npmmirror.com/merge2/-/merge2-1.4.1.tgz",
@@ -3460,6 +3827,19 @@
"node": ">= 0.6"
}
},
"node_modules/mimic-fn": {
"version": "4.0.0",
"resolved": "https://registry.npmmirror.com/mimic-fn/-/mimic-fn-4.0.0.tgz",
"integrity": "sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==",
"dev": true,
"license": "MIT",
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/mimic-response": {
"version": "3.1.0",
"resolved": "https://registry.npmmirror.com/mimic-response/-/mimic-response-3.1.0.tgz",
@@ -3511,6 +3891,26 @@
"integrity": "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==",
"license": "MIT"
},
"node_modules/mlly": {
"version": "1.8.0",
"resolved": "https://registry.npmmirror.com/mlly/-/mlly-1.8.0.tgz",
"integrity": "sha512-l8D9ODSRWLe2KHJSifWGwBqpTZXIXTeo8mlKjY+E2HAakaTeNpqAyBZ8GSqLzHgw4XmHmC8whvpjJNMbFZN7/g==",
"dev": true,
"license": "MIT",
"dependencies": {
"acorn": "^8.15.0",
"pathe": "^2.0.3",
"pkg-types": "^1.3.1",
"ufo": "^1.6.1"
}
},
"node_modules/mlly/node_modules/pathe": {
"version": "2.0.3",
"resolved": "https://registry.npmmirror.com/pathe/-/pathe-2.0.3.tgz",
"integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
"dev": true,
"license": "MIT"
},
"node_modules/ms": {
"version": "2.1.3",
"resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
@@ -3679,6 +4079,35 @@
"node": ">=0.10.0"
}
},
"node_modules/npm-run-path": {
"version": "5.3.0",
"resolved": "https://registry.npmmirror.com/npm-run-path/-/npm-run-path-5.3.0.tgz",
"integrity": "sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==",
"dev": true,
"license": "MIT",
"dependencies": {
"path-key": "^4.0.0"
},
"engines": {
"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/npm-run-path/node_modules/path-key": {
"version": "4.0.0",
"resolved": "https://registry.npmmirror.com/path-key/-/path-key-4.0.0.tgz",
"integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==",
"dev": true,
"license": "MIT",
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/object-assign": {
"version": "4.1.1",
"resolved": "https://registry.npmmirror.com/object-assign/-/object-assign-4.1.1.tgz",
@@ -3731,6 +4160,22 @@
"wrappy": "1"
}
},
"node_modules/onetime": {
"version": "6.0.0",
"resolved": "https://registry.npmmirror.com/onetime/-/onetime-6.0.0.tgz",
"integrity": "sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==",
"dev": true,
"license": "MIT",
"dependencies": {
"mimic-fn": "^4.0.0"
},
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/p-limit": {
"version": "7.2.0",
"resolved": "https://registry.npmmirror.com/p-limit/-/p-limit-7.2.0.tgz",
@@ -3811,6 +4256,23 @@
"integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==",
"license": "MIT"
},
"node_modules/pathe": {
"version": "1.1.2",
"resolved": "https://registry.npmmirror.com/pathe/-/pathe-1.1.2.tgz",
"integrity": "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==",
"dev": true,
"license": "MIT"
},
"node_modules/pathval": {
"version": "1.1.1",
"resolved": "https://registry.npmmirror.com/pathval/-/pathval-1.1.1.tgz",
"integrity": "sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==",
"dev": true,
"license": "MIT",
"engines": {
"node": "*"
}
},
"node_modules/picocolors": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -3850,6 +4312,25 @@
"node": ">= 6"
}
},
"node_modules/pkg-types": {
"version": "1.3.1",
"resolved": "https://registry.npmmirror.com/pkg-types/-/pkg-types-1.3.1.tgz",
"integrity": "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==",
"dev": true,
"license": "MIT",
"dependencies": {
"confbox": "^0.1.8",
"mlly": "^1.7.4",
"pathe": "^2.0.1"
}
},
"node_modules/pkg-types/node_modules/pathe": {
"version": "2.0.3",
"resolved": "https://registry.npmmirror.com/pathe/-/pathe-2.0.3.tgz",
"integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
"dev": true,
"license": "MIT"
},
"node_modules/postcss": {
"version": "8.5.6",
"resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
@@ -4039,6 +4520,34 @@
"node": ">=10"
}
},
"node_modules/pretty-format": {
"version": "29.7.0",
"resolved": "https://registry.npmmirror.com/pretty-format/-/pretty-format-29.7.0.tgz",
"integrity": "sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==",
"dev": true,
"license": "MIT",
"dependencies": {
"@jest/schemas": "^29.6.3",
"ansi-styles": "^5.0.0",
"react-is": "^18.0.0"
},
"engines": {
"node": "^14.15.0 || ^16.10.0 || >=18.0.0"
}
},
"node_modules/pretty-format/node_modules/ansi-styles": {
"version": "5.2.0",
"resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-5.2.0.tgz",
"integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
"dev": true,
"license": "MIT",
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/chalk/ansi-styles?sponsor=1"
}
},
"node_modules/process-nextick-args": {
"version": "2.0.1",
"resolved": "https://registry.npmmirror.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
@@ -4081,6 +4590,23 @@
"once": "^1.3.1"
}
},
"node_modules/pure-rand": {
"version": "6.1.0",
"resolved": "https://registry.npmmirror.com/pure-rand/-/pure-rand-6.1.0.tgz",
"integrity": "sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA==",
"dev": true,
"funding": [
{
"type": "individual",
"url": "https://github.com/sponsors/dubzzz"
},
{
"type": "opencollective",
"url": "https://opencollective.com/fast-check"
}
],
"license": "MIT"
},
"node_modules/qs": {
"version": "6.13.0",
"resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz",
@@ -4181,6 +4707,13 @@
"react": "^18.3.1"
}
},
"node_modules/react-is": {
"version": "18.3.1",
"resolved": "https://registry.npmmirror.com/react-is/-/react-is-18.3.1.tgz",
"integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",
"dev": true,
"license": "MIT"
},
"node_modules/react-photo-view": {
"version": "1.2.7",
"resolved": "https://registry.npmmirror.com/react-photo-view/-/react-photo-view-1.2.7.tgz",
@@ -4624,6 +5157,13 @@
"url": "https://github.com/sponsors/ljharb"
}
},
"node_modules/siginfo": {
"version": "2.0.0",
"resolved": "https://registry.npmmirror.com/siginfo/-/siginfo-2.0.0.tgz",
"integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
"dev": true,
"license": "ISC"
},
"node_modules/signal-exit": {
"version": "4.1.0",
"resolved": "https://registry.npmmirror.com/signal-exit/-/signal-exit-4.1.0.tgz",
@@ -4850,6 +5390,13 @@
"node": ">=0.10.0"
}
},
"node_modules/stackback": {
"version": "0.0.2",
"resolved": "https://registry.npmmirror.com/stackback/-/stackback-0.0.2.tgz",
"integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
"dev": true,
"license": "MIT"
},
"node_modules/statuses": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
@@ -4859,6 +5406,13 @@
"node": ">= 0.8"
}
},
"node_modules/std-env": {
"version": "3.10.0",
"resolved": "https://registry.npmmirror.com/std-env/-/std-env-3.10.0.tgz",
"integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
"dev": true,
"license": "MIT"
},
"node_modules/string_decoder": {
"version": "1.3.0",
"resolved": "https://registry.npmmirror.com/string_decoder/-/string_decoder-1.3.0.tgz",
@@ -4964,6 +5518,19 @@
"node": ">=8"
}
},
"node_modules/strip-final-newline": {
"version": "3.0.0",
"resolved": "https://registry.npmmirror.com/strip-final-newline/-/strip-final-newline-3.0.0.tgz",
"integrity": "sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==",
"dev": true,
"license": "MIT",
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/strip-json-comments": {
"version": "2.0.1",
"resolved": "https://registry.npmmirror.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
@@ -4973,6 +5540,26 @@
"node": ">=0.10.0"
}
},
"node_modules/strip-literal": {
"version": "2.1.1",
"resolved": "https://registry.npmmirror.com/strip-literal/-/strip-literal-2.1.1.tgz",
"integrity": "sha512-631UJ6O00eNGfMiWG78ck80dfBab8X6IVFB51jZK5Icd7XAs60Z5y7QdSd/wGIklnWvRbUNloVzhOKKmutxQ6Q==",
"dev": true,
"license": "MIT",
"dependencies": {
"js-tokens": "^9.0.1"
},
"funding": {
"url": "https://github.com/sponsors/antfu"
}
},
"node_modules/strip-literal/node_modules/js-tokens": {
"version": "9.0.1",
"resolved": "https://registry.npmmirror.com/js-tokens/-/js-tokens-9.0.1.tgz",
"integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==",
"dev": true,
"license": "MIT"
},
"node_modules/sucrase": {
"version": "3.35.1",
"resolved": "https://registry.npmmirror.com/sucrase/-/sucrase-3.35.1.tgz",
@@ -5124,6 +5711,13 @@
"node": ">=0.8"
}
},
"node_modules/tinybench": {
"version": "2.9.0",
"resolved": "https://registry.npmmirror.com/tinybench/-/tinybench-2.9.0.tgz",
"integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
"dev": true,
"license": "MIT"
},
"node_modules/tinyglobby": {
"version": "0.2.15",
"resolved": "https://registry.npmmirror.com/tinyglobby/-/tinyglobby-0.2.15.tgz",
@@ -5172,6 +5766,26 @@
"url": "https://github.com/sponsors/jonschlinkert"
}
},
"node_modules/tinypool": {
"version": "0.8.4",
"resolved": "https://registry.npmmirror.com/tinypool/-/tinypool-0.8.4.tgz",
"integrity": "sha512-i11VH5gS6IFeLY3gMBQ00/MmLncVP7JLXOw1vlgkytLmJK7QnEr7NXf0LBdxfmNPAeyetukOk0bOYrJrFGjYJQ==",
"dev": true,
"license": "MIT",
"engines": {
"node": ">=14.0.0"
}
},
"node_modules/tinyspy": {
"version": "2.2.1",
"resolved": "https://registry.npmmirror.com/tinyspy/-/tinyspy-2.2.1.tgz",
"integrity": "sha512-KYad6Vy5VDWV4GH3fjpseMQ/XU2BhIYP7Vzd0LG44qRWm/Yt2WCOTicFdvmgo6gWaqooMQCawTtILVQJupKu7A==",
"dev": true,
"license": "MIT",
"engines": {
"node": ">=14.0.0"
}
},
"node_modules/to-regex-range": {
"version": "5.0.1",
"resolved": "https://registry.npmmirror.com/to-regex-range/-/to-regex-range-5.0.1.tgz",
@@ -5229,6 +5843,16 @@
"node": "*"
}
},
"node_modules/type-detect": {
"version": "4.1.0",
"resolved": "https://registry.npmmirror.com/type-detect/-/type-detect-4.1.0.tgz",
"integrity": "sha512-Acylog8/luQ8L7il+geoSxhEkazvkslg7PSNKOX59mbB9cOveP5aq9h74Y7YU8yDpJwetzQQrfIwtf4Wp4LKcw==",
"dev": true,
"license": "MIT",
"engines": {
"node": ">=4"
}
},
"node_modules/type-is": {
"version": "1.6.18",
"resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
@@ -5242,6 +5866,13 @@
"node": ">= 0.6"
}
},
"node_modules/ufo": {
"version": "1.6.1",
"resolved": "https://registry.npmmirror.com/ufo/-/ufo-1.6.1.tgz",
"integrity": "sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA==",
"dev": true,
"license": "MIT"
},
"node_modules/undefsafe": {
"version": "2.0.5",
"resolved": "https://registry.npmmirror.com/undefsafe/-/undefsafe-2.0.5.tgz",
@@ -5388,6 +6019,95 @@
}
}
},
"node_modules/vite-node": {
"version": "1.6.1",
"resolved": "https://registry.npmmirror.com/vite-node/-/vite-node-1.6.1.tgz",
"integrity": "sha512-YAXkfvGtuTzwWbDSACdJSg4A4DZiAqckWe90Zapc/sEX3XvHcw1NdurM/6od8J207tSDqNbSsgdCacBgvJKFuA==",
"dev": true,
"license": "MIT",
"dependencies": {
"cac": "^6.7.14",
"debug": "^4.3.4",
"pathe": "^1.1.1",
"picocolors": "^1.0.0",
"vite": "^5.0.0"
},
"bin": {
"vite-node": "vite-node.mjs"
},
"engines": {
"node": "^18.0.0 || >=20.0.0"
},
"funding": {
"url": "https://opencollective.com/vitest"
}
},
"node_modules/vitest": {
"version": "1.6.1",
"resolved": "https://registry.npmmirror.com/vitest/-/vitest-1.6.1.tgz",
"integrity": "sha512-Ljb1cnSJSivGN0LqXd/zmDbWEM0RNNg2t1QW/XUhYl/qPqyu7CsqeWtqQXHVaJsecLPuDoak2oJcZN2QoRIOag==",
"dev": true,
"license": "MIT",
"dependencies": {
"@vitest/expect": "1.6.1",
"@vitest/runner": "1.6.1",
"@vitest/snapshot": "1.6.1",
"@vitest/spy": "1.6.1",
"@vitest/utils": "1.6.1",
"acorn-walk": "^8.3.2",
"chai": "^4.3.10",
"debug": "^4.3.4",
"execa": "^8.0.1",
"local-pkg": "^0.5.0",
"magic-string": "^0.30.5",
"pathe": "^1.1.1",
"picocolors": "^1.0.0",
"std-env": "^3.5.0",
"strip-literal": "^2.0.0",
"tinybench": "^2.5.1",
"tinypool": "^0.8.3",
"vite": "^5.0.0",
"vite-node": "1.6.1",
"why-is-node-running": "^2.2.2"
},
"bin": {
"vitest": "vitest.mjs"
},
"engines": {
"node": "^18.0.0 || >=20.0.0"
},
"funding": {
"url": "https://opencollective.com/vitest"
},
"peerDependencies": {
"@edge-runtime/vm": "*",
"@types/node": "^18.0.0 || >=20.0.0",
"@vitest/browser": "1.6.1",
"@vitest/ui": "1.6.1",
"happy-dom": "*",
"jsdom": "*"
},
"peerDependenciesMeta": {
"@edge-runtime/vm": {
"optional": true
},
"@types/node": {
"optional": true
},
"@vitest/browser": {
"optional": true
},
"@vitest/ui": {
"optional": true
},
"happy-dom": {
"optional": true
},
"jsdom": {
"optional": true
}
}
},
"node_modules/which": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -5403,6 +6123,23 @@
"node": ">= 8"
}
},
"node_modules/why-is-node-running": {
"version": "2.3.0",
"resolved": "https://registry.npmmirror.com/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
"integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
"dev": true,
"license": "MIT",
"dependencies": {
"siginfo": "^2.0.0",
"stackback": "0.0.2"
},
"bin": {
"why-is-node-running": "cli.js"
},
"engines": {
"node": ">=8"
}
},
"node_modules/wrap-ansi": {
"version": "8.1.0",
"resolved": "https://registry.npmmirror.com/wrap-ansi/-/wrap-ansi-8.1.0.tgz",