create-pardx-scaffold 0.1.1 → 0.1.3

package/template/apps/web/lib/audio-buffer-queue.ts

@@ -1,273 +0,0 @@
-/**
- * @fileoverview 音频缓冲队列
- *
- * 用于处理 token refresh 期间的音频数据缓冲
- * 确保长时间录音场景下不丢失音频数据
- *
- * @module lib/audio-buffer-queue
- */
-
-interface AudioChunk {
-  audioData: string; // base64 encoded
-  sequence: number;
-  timestamp: number;
-}
-
-interface AudioBufferQueueOptions {
-  /** 最大队列长度（默认 100） */
-  maxQueueSize?: number;
-  /** 发送重试次数（默认 3） */
-  maxRetries?: number;
-  /** 重试延迟（毫秒，默认 1000） */
-  retryDelay?: number;
-}
-
-/**
- * 音频缓冲队列
- *
- * @description
- * 解决 JWT token refresh 导致的音频数据丢失问题：
- * 1. Token 过期时，自动缓冲音频数据到队列
- * 2. Token 刷新完成后，按序重新发送队列中的数据
- * 3. 支持失败重试机制
- *
- * @example
- * ```typescript
- * const queue = new AudioBufferQueue({
- *   maxQueueSize: 100,
- *   maxRetries: 3,
- *   retryDelay: 1000,
- * });
- *
- * // 发送音频数据（自动处理缓冲和重试）
- * await queue.send(
- *   sessionId,
- *   audioData,
- *   sequence,
- *   (sessionId, audioData, sequence) => apiClient.sendAudioChunk({...})
- * );
- *
- * // 手动触发 token refresh
- * await queue.handleTokenRefresh(async () => {
- *   await refreshAccessToken();
- * });
- * ```
- */
-export class AudioBufferQueue {
-  private queue: AudioChunk[] = [];
-  private isRefreshing = false;
-  private isSending = false;
-  private readonly options: Required<AudioBufferQueueOptions>;
-
-  constructor(options: AudioBufferQueueOptions = {}) {
-    this.options = {
-      maxQueueSize: options.maxQueueSize ?? 100,
-      maxRetries: options.maxRetries ?? 3,
-      retryDelay: options.retryDelay ?? 1000,
-    };
-  }
-
-  /**
-   * 发送音频数据
-   *
-   * @param sessionId - Session ID
-   * @param audioData - Base64 encoded audio data
-   * @param sequence - Sequence number
-   * @param sendFn - 发送函数
-   * @returns Promise
-   */
-  async send(
-    sessionId: string,
-    audioData: string,
-    sequence: number,
-    sendFn: (
-      sessionId: string,
-      audioData: string,
-      sequence: number,
-    ) => Promise<void>,
-  ): Promise<void> {
-    const chunk: AudioChunk = {
-      audioData,
-      sequence,
-      timestamp: Date.now(),
-    };
-
-    // 如果正在 refresh 或队列中有数据，先缓冲
-    if (this.isRefreshing || this.queue.length > 0) {
-      this.enqueue(chunk);
-      return;
-    }
-
-    // 尝试直接发送
-    try {
-      await sendFn(sessionId, audioData, sequence);
-    } catch (error) {
-      // 检查是否是认证错误
-      if (this.isAuthError(error)) {
-        // 认证错误，缓冲当前数据并触发 refresh
-        this.enqueue(chunk);
-        throw error; // 抛出错误，让调用方知道需要 refresh
-      } else {
-        // 其他错误，直接抛出
-        throw error;
-      }
-    }
-  }
-
-  /**
-   * 处理 token refresh
-   *
-   * @param refreshFn - Token refresh 函数
-   */
-  async handleTokenRefresh(refreshFn: () => Promise<void>): Promise<void> {
-    if (this.isRefreshing) {
-      console.warn('[AudioBufferQueue] Already refreshing, skipping');
-      return;
-    }
-
-    this.isRefreshing = true;
-
-    try {
-      // 执行 token refresh
-      await refreshFn();
-
-      // Refresh 成功，flush 队列
-      await this.flush(async (_chunk) => {
-        // 这里需要调用方传入 sendFn
-        // 所以我们需要调整设计
-      });
-    } catch (error) {
-      console.error('[AudioBufferQueue] Token refresh failed:', error);
-      throw error;
-    } finally {
-      this.isRefreshing = false;
-    }
-  }
-
-  /**
-   * 将音频数据加入缓冲队列
-   */
-  private enqueue(chunk: AudioChunk): void {
-    if (this.queue.length >= this.options.maxQueueSize) {
-      console.warn('[AudioBufferQueue] Queue is full, dropping oldest chunk', {
-        queueSize: this.queue.length,
-        droppedChunk: this.queue[0],
-      });
-      this.queue.shift(); // 移除最旧的数据
-    }
-
-    this.queue.push(chunk);
-    console.log('[AudioBufferQueue] Chunk enqueued', {
-      sequence: chunk.sequence,
-      queueSize: this.queue.length,
-    });
-  }
-
-  /**
-   * Flush 队列：按序发送所有缓冲的音频数据
-   */
-  async flush(
-    sendFn: (
-      sessionId: string,
-      audioData: string,
-      sequence: number,
-    ) => Promise<void>,
-    sessionId: string,
-  ): Promise<void> {
-    if (this.isSending) {
-      console.warn('[AudioBufferQueue] Already flushing, skipping');
-      return;
-    }
-
-    if (this.queue.length === 0) {
-      return;
-    }
-
-    this.isSending = true;
-    console.log('[AudioBufferQueue] Flushing queue', {
-      queueSize: this.queue.length,
-    });
-
-    const chunksToSend = [...this.queue];
-    this.queue = []; // 清空队列
-
-    for (const chunk of chunksToSend) {
-      let retries = 0;
-      while (retries < this.options.maxRetries) {
-        try {
-          await sendFn(sessionId, chunk.audioData, chunk.sequence);
-          break; // 发送成功，跳出重试循环
-        } catch (error) {
-          retries++;
-          console.error(
-            `[AudioBufferQueue] Failed to send chunk (attempt ${retries}/${this.options.maxRetries})`,
-            {
-              sequence: chunk.sequence,
-              error,
-            },
-          );
-
-          if (retries >= this.options.maxRetries) {
-            console.error(
-              '[AudioBufferQueue] Max retries reached, dropping chunk',
-              {
-                sequence: chunk.sequence,
-              },
-            );
-            // TODO: 通知用户数据丢失
-            break;
-          }
-
-          // 等待重试延迟
-          await this.sleep(this.options.retryDelay);
-        }
-      }
-    }
-
-    this.isSending = false;
-    console.log('[AudioBufferQueue] Queue flushed');
-  }
-
-  /**
-   * 检查是否是认证错误
-   */
-  private isAuthError(error: unknown): boolean {
-    if (error && typeof error === 'object') {
-      const err = error as unknown;
-      return (
-        err.status === 401 ||
-        err.statusCode === 401 ||
-        err.code === 'UNAUTHORIZED' ||
-        err.message?.includes('Unauthorized') ||
-        err.message?.includes('token')
-      );
-    }
-    return false;
-  }
-
-  /**
-   * 延迟函数
-   */
-  private sleep(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
-  /**
-   * 获取队列状态
-   */
-  getStatus() {
-    return {
-      queueSize: this.queue.length,
-      isRefreshing: this.isRefreshing,
-      isSending: this.isSending,
-    };
-  }
-
-  /**
-   * 清空队列
-   */
-  clear(): void {
-    this.queue = [];
-    console.log('[AudioBufferQueue] Queue cleared');
-  }
-}

package/template/apps/web/lib/upload/folder-utils.ts

@@ -1,295 +0,0 @@
-/**
- * 文件夹上传工具函数
- * 支持解析 webkitdirectory 和拖拽上传的文件夹结构
- */
-
-/**
- * 文件夹结构
- */
-export interface FolderStruct {
-  name: string;
-  path: string;
-  children?: FolderStruct[];
-}
-
-/**
- * 文件及其相对路径信息
- */
-export interface FileWithPath {
-  file: File;
-  /** 相对路径（不含文件名） */
-  relativePath: string;
-  /** 完整相对路径（含文件名） */
-  fullPath: string;
-}
-
-/**
- * 解析 webkitdirectory 选择的文件列表
- * 从 webkitRelativePath 提取文件夹结构
- *
- * @param files 文件列表
- * @returns 文件夹结构和文件列表
- */
-export function parseWebkitDirectory(files: File[]): {
-  folderStruct: FolderStruct | null;
-  filesWithPath: FileWithPath[];
-} {
-  if (files.length === 0) {
-    return { folderStruct: null, filesWithPath: [] };
-  }
-
-  const filesWithPath: FileWithPath[] = [];
-  const folderPaths = new Set<string>();
-
-  // 收集所有文件夹路径
-  for (const file of files) {
-    // webkitRelativePath 格式: "folder/subfolder/file.txt"
-    const relativePath = (file as File & { webkitRelativePath?: string })
-      .webkitRelativePath;
-    if (!relativePath) continue;
-
-    const pathParts = relativePath.split('/');
-    pathParts.pop(); // Remove file name from path
-    const dirPath = pathParts.join('/');
-
-    filesWithPath.push({
-      file,
-      relativePath: dirPath,
-      fullPath: relativePath,
-    });
-
-    // 收集所有父级文件夹路径
-    let currentPath = '';
-    for (const part of pathParts) {
-      currentPath = currentPath ? `${currentPath}/${part}` : part;
-      folderPaths.add(currentPath);
-    }
-  }
-
-  // 构建文件夹结构树
-  const folderStruct = buildFolderStruct(Array.from(folderPaths));
-
-  return { folderStruct, filesWithPath };
-}
-
-/**
- * 从路径列表构建文件夹结构
- */
-function buildFolderStruct(paths: string[]): FolderStruct | null {
-  if (paths.length === 0) return null;
-
-  // 按深度排序
-  const sortedPaths = paths.sort((a, b) => {
-    const depthA = a.split('/').length;
-    const depthB = b.split('/').length;
-    return depthA - depthB;
-  });
-
-  // 获取根文件夹名称
-  const rootPath = sortedPaths[0] || '';
-  const rootName = rootPath.split('/')[0] || '';
-
-  // 构建树结构
-  const root: FolderStruct = { name: rootName };
-  const nodeMap = new Map<string, FolderStruct>();
-  nodeMap.set(rootName, root);
-
-  for (const path of sortedPaths) {
-    const parts = path.split('/');
-    if (parts.length === 1) continue; // 跳过根节点
-
-    let currentPath = parts[0];
-    let parentNode = nodeMap.get(currentPath || '');
-    if (!parentNode) continue; // Skip if root node not found
-
-    for (let i = 1; i < parts.length; i++) {
-      currentPath = `${currentPath}/${parts[i]}`;
-
-      if (!nodeMap.has(currentPath)) {
-        const newNode: FolderStruct = { name: parts[i] || '' };
-        if (!parentNode.children) {
-          parentNode.children = [];
-        }
-        parentNode.children.push(newNode);
-        nodeMap.set(currentPath, newNode);
-      }
-
-      const nextNode = nodeMap.get(currentPath);
-      if (!nextNode) break; // Skip if node not found
-      parentNode = nextNode;
-    }
-  }
-
-  return root;
-}
-
-/**
- * 从 DataTransferItemList 解析拖拽的文件和文件夹
- * 使用 webkitGetAsEntry API 递归读取文件夹内容
- */
-export async function parseDragDropItems(items: DataTransferItemList): Promise<{
-  folderStruct: FolderStruct | null;
-  filesWithPath: FileWithPath[];
-}> {
-  const filesWithPath: FileWithPath[] = [];
-  const folderPaths = new Set<string>();
-  const rootFolders: FolderStruct[] = [];
-
-  const entries = Array.from(items)
-    .map((item) => item.webkitGetAsEntry?.())
-    .filter((entry): entry is FileSystemEntry => entry !== null);
-
-  for (const entry of entries) {
-    if (entry.isDirectory) {
-      const dirEntry = entry as FileSystemDirectoryEntry;
-      const folderStruct = await readDirectoryEntry(
-        dirEntry,
-        '',
-        filesWithPath,
-        folderPaths,
-      );
-      if (folderStruct) {
-        rootFolders.push(folderStruct);
-      }
-    } else if (entry.isFile) {
-      const fileEntry = entry as FileSystemFileEntry;
-      const file = await getFileFromEntry(fileEntry);
-      if (file) {
-        filesWithPath.push({
-          file,
-          relativePath: '',
-          fullPath: file.name,
-        });
-      }
-    }
-  }
-
-  // 如果只有一个根文件夹，直接返回
-  // 如果有多个，创建一个虚拟根节点
-  let folderStruct: FolderStruct | null = null;
-  if (rootFolders.length === 1) {
-    folderStruct = rootFolders[0] || null;
-  } else if (rootFolders.length > 1) {
-    // 多个根文件夹不需要虚拟根节点，分别处理
-    folderStruct = rootFolders[0] || null; // 暂时只处理第一个
-  }
-
-  return { folderStruct, filesWithPath };
-}
-
-/**
- * 递归读取目录条目
- */
-async function readDirectoryEntry(
-  dirEntry: FileSystemDirectoryEntry,
-  parentPath: string,
-  filesWithPath: FileWithPath[],
-  folderPaths: Set<string>,
-): Promise<FolderStruct> {
-  const currentPath = parentPath
-    ? `${parentPath}/${dirEntry.name}`
-    : dirEntry.name;
-  folderPaths.add(currentPath);
-
-  const folderStruct: FolderStruct = { name: dirEntry.name };
-  const children: FolderStruct[] = [];
-
-  const entries = await readAllDirectoryEntries(dirEntry);
-
-  for (const entry of entries) {
-    if (entry.isDirectory) {
-      const childStruct = await readDirectoryEntry(
-        entry as FileSystemDirectoryEntry,
-        currentPath,
-        filesWithPath,
-        folderPaths,
-      );
-      children.push(childStruct);
-    } else if (entry.isFile) {
-      const file = await getFileFromEntry(entry as FileSystemFileEntry);
-      if (file) {
-        filesWithPath.push({
-          file,
-          relativePath: currentPath,
-          fullPath: `${currentPath}/${file.name}`,
-        });
-      }
-    }
-  }
-
-  if (children.length > 0) {
-    folderStruct.children = children;
-  }
-
-  return folderStruct;
-}
-
-/**
- * 读取目录中的所有条目
- */
-function readAllDirectoryEntries(
-  dirEntry: FileSystemDirectoryEntry,
-): Promise<FileSystemEntry[]> {
-  return new Promise((resolve, reject) => {
-    const reader = dirEntry.createReader();
-    const entries: FileSystemEntry[] = [];
-
-    const readEntries = () => {
-      reader.readEntries(
-        (results) => {
-          if (results.length === 0) {
-            resolve(entries);
-          } else {
-            entries.push(...results);
-            readEntries(); // 继续读取（API 可能分批返回）
-          }
-        },
-        (error) => reject(error),
-      );
-    };
-
-    readEntries();
-  });
-}
-
-/**
- * 从 FileSystemFileEntry 获取 File 对象
- */
-function getFileFromEntry(
-  fileEntry: FileSystemFileEntry,
-): Promise<File | null> {
-  return new Promise((resolve) => {
-    fileEntry.file(
-      (file) => resolve(file),
-      () => resolve(null),
-    );
-  });
-}
-
-/**
- * 根据文件夹结构和创建的文件夹 ID 映射，获取文件应该上传到的文件夹 ID
- */
-export function getTargetFolderId(
-  relativePath: string,
-  folderIdMap: Map<string, string>,
-  defaultFolderId: string,
-): string {
-  if (!relativePath) {
-    return defaultFolderId;
-  }
-
-  // 尝试找到最近的父文件夹 ID
-  const pathParts = relativePath.split('/');
-  let currentPath = '';
-  let lastFoundId = defaultFolderId;
-
-  for (const part of pathParts) {
-    currentPath = currentPath ? `${currentPath}/${part}` : part;
-    const folderId = folderIdMap.get(currentPath);
-    if (folderId) {
-      lastFoundId = folderId;
-    }
-  }
-
-  return lastFoundId;
-}