@spacecorexdev/core 0.0.2 → 0.0.5

package/src/ui/UIFilePreview/IndexedDBUtils.ts

@@ -0,0 +1,564 @@
+/**
+ * IndexedDB 工具模块
+ * 用于本地存储编辑器的文件数据
+ */
+
+const DB_NAME = 'FileEditorDB';
+const DB_VERSION = 2; // 从 1 升级到 2，新增 localFiles store
+const STORE_NAME = 'files';
+const LOCAL_FILES_STORE = 'localFiles';
+
+export type FileType = 'pptx' | 'xlsx' | 'md' | 'markdown' | 'docx' | 'rdoc';
+
+/** 本地文件记录（包含未上传的新文件和服务器文件的本地未同步修改） */
+export interface LocalFileRecord {
+  /** 本地唯一标识 */
+  localId: string;
+  /** 用户 ID */
+  userId: string;
+  /** 项目 ID */
+  projectId: string;
+  /** 父文件夹 ID（服务器文件 ID 或本地文件夹 ID，根目录为 null） */
+  parentId: string | null;
+  /** 文件名 */
+  fileName: string;
+  /** 文件类型 */
+  fileType: FileType;
+  /** 对应服务器文件 ID：null 表示从未上传的本地新文件；非 null 表示该服务器文件的本地修改版本 */
+  serverFileId: string | null;
+  /** 是否为仅本地存在（从未上传） */
+  isLocalOnly: boolean;
+  /** 是否有未同步的修改 */
+  hasUnsyncedChanges: boolean;
+  /** 原始服务器文件快照（用于离线编辑后，上传时可回填服务器元数据，仅 serverFileId 非空时有值） */
+  originalServerFile?: any | null;
+  /** 原始服务器文件内容（用于差分上传基准，仅 serverFileId 非空时有值；二进制为 ArrayBuffer，Markdown 为 string） */
+  originalContent?: ArrayBuffer | string;
+  /** 文件实际内容（二进制为 ArrayBuffer，Markdown 为 string） */
+  content: ArrayBuffer | string;
+  /** 文件大小（字节） */
+  fileSize: number;
+  /** 创建时间戳 */
+  createdAt: number;
+  /** 更新时间戳 */
+  updatedAt: number;
+}
+
+/**
+ * 打开 IndexedDB 数据库
+ */
+function openDB(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+
+    request.onerror = () => {
+      reject(new Error('打开 IndexedDB 失败'));
+    };
+
+    request.onsuccess = () => {
+      resolve(request.result);
+    };
+
+    request.onupgradeneeded = (event) => {
+      const db = (event.target as IDBOpenDBRequest).result;
+      // v1: files store
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        const store = db.createObjectStore(STORE_NAME, { keyPath: 'id' });
+        store.createIndex('userId', 'userId', { unique: false });
+        store.createIndex('fileName', 'fileName', { unique: false });
+        store.createIndex('fileType', 'fileType', { unique: false });
+        store.createIndex('userId_fileName_type', ['userId', 'fileName', 'fileType'], { unique: true });
+      }
+      // v2: localFiles store（文件管理器中可见的本地未上传/未同步文件）
+      if (!db.objectStoreNames.contains(LOCAL_FILES_STORE)) {
+        const localStore = db.createObjectStore(LOCAL_FILES_STORE, { keyPath: 'localId' });
+        localStore.createIndex('userId', 'userId', { unique: false });
+        localStore.createIndex('projectId', 'projectId', { unique: false });
+        localStore.createIndex('userId_projectId', ['userId', 'projectId'], { unique: false });
+        localStore.createIndex('userId_serverFileId', ['userId', 'serverFileId'], { unique: false });
+        localStore.createIndex('serverFileId', 'serverFileId', { unique: false });
+      }
+    };
+  });
+}
+
+/**
+ * 保存文件数据到 IndexedDB
+ */
+export async function saveFile(
+  userId: string,
+  fileName: string,
+  fileType: FileType,
+  data: any
+): Promise<void> {
+  try {
+    const db = await openDB();
+    const transaction = db.transaction(STORE_NAME, 'readwrite');
+    const store = transaction.objectStore(STORE_NAME);
+
+    const record = {
+      id: `${userId}_${fileName}_${fileType}`,
+      userId,
+      fileName,
+      fileType,
+      data,
+      updatedAt: Date.now()
+    };
+
+    return new Promise((resolve, reject) => {
+      const request = store.put(record);
+      request.onsuccess = () => {
+        db.close();
+        resolve();
+      };
+      request.onerror = () => {
+        db.close();
+        reject(new Error('保存文件失败'));
+      };
+    });
+  } catch (error) {
+    console.error('保存文件到 IndexedDB 失败:', error);
+    throw error;
+  }
+}
+
+/**
+ * 从 IndexedDB 读取文件数据
+ */
+export async function loadFile(
+  userId: string,
+  fileName: string,
+  fileType: FileType
+): Promise<any | null> {
+  try {
+    const db = await openDB();
+    const transaction = db.transaction(STORE_NAME, 'readonly');
+    const store = transaction.objectStore(STORE_NAME);
+    const index = store.index('userId_fileName_type');
+
+    return new Promise((resolve, reject) => {
+      const request = index.get([userId, fileName, fileType]);
+      request.onsuccess = () => {
+        db.close();
+        if (request.result) {
+          resolve(request.result.data);
+        } else {
+          resolve(null);
+        }
+      };
+      request.onerror = () => {
+        db.close();
+        reject(new Error('读取文件失败'));
+      };
+    });
+  } catch (error) {
+    console.error('从 IndexedDB 读取文件失败:', error);
+    return null;
+  }
+}
+
+/**
+ * 删除 IndexedDB 中的文件
+ */
+export async function deleteFile(
+  userId: string,
+  fileName: string,
+  fileType: FileType
+): Promise<void> {
+  try {
+    const db = await openDB();
+    const transaction = db.transaction(STORE_NAME, 'readwrite');
+    const store = transaction.objectStore(STORE_NAME);
+
+    return new Promise((resolve, reject) => {
+      const request = store.delete(`${userId}_${fileName}_${fileType}`);
+      request.onsuccess = () => {
+        db.close();
+        resolve();
+      };
+      request.onerror = () => {
+        db.close();
+        reject(new Error('删除文件失败'));
+      };
+    });
+  } catch (error) {
+    console.error('从 IndexedDB 删除文件失败:', error);
+    throw error;
+  }
+}
+
+/**
+ * 获取所有本地缓存的文件列表（指定用户）
+ */
+export async function listFiles(userId: string, fileType?: FileType): Promise<Array<{ fileName: string; fileType: FileType; updatedAt: number }>> {
+  try {
+    const db = await openDB();
+    const transaction = db.transaction(STORE_NAME, 'readonly');
+    const store = transaction.objectStore(STORE_NAME);
+
+    return new Promise((resolve, reject) => {
+      const request = store.getAll();
+      request.onsuccess = () => {
+        db.close();
+        let results = request.result.filter((item: any) => item.userId === userId);
+        if (fileType) {
+          results = results.filter((item: any) => item.fileType === fileType);
+        }
+        resolve(results.map((item: any) => ({
+          fileName: item.fileName,
+          fileType: item.fileType,
+          updatedAt: item.updatedAt
+        })));
+      };
+      request.onerror = () => {
+        db.close();
+        reject(new Error('获取文件列表失败'));
+      };
+    });
+  } catch (error) {
+    console.error('获取文件列表失败:', error);
+    return [];
+  }
+}
+
+// ============================================================
+// 以下是新增的 localFiles store 相关 API（用于文件管理器中可见的本地未上传/未同步文件）
+// ============================================================
+
+/** 生成本地文件唯一 ID */
+function generateLocalId(): string {
+  return `local_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+
+/**
+ * 计算内容大小（字节）
+ */
+function calculateContentSize(content: ArrayBuffer | string): number {
+  if (typeof content === 'string') {
+    // UTF-8 字节长度
+    return new Blob([content]).size;
+  }
+  return content.byteLength;
+}
+
+/**
+ * 创建并保存一个新的本地仅存在文件（未上传到服务器）
+ */
+export async function createLocalOnlyFile(params: {
+  userId: string;
+  projectId: string;
+  parentId: string | null;
+  fileName: string;
+  fileType: FileType;
+  content: ArrayBuffer | string;
+}): Promise<LocalFileRecord> {
+  const now = Date.now();
+  const record: LocalFileRecord = {
+    localId: generateLocalId(),
+    userId: params.userId,
+    projectId: params.projectId,
+    parentId: params.parentId,
+    fileName: params.fileName,
+    fileType: params.fileType,
+    serverFileId: null,
+    isLocalOnly: true,
+    hasUnsyncedChanges: true,
+    originalServerFile: null,
+    content: params.content,
+    fileSize: calculateContentSize(params.content),
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  try {
+    const db = await openDB();
+    const transaction = db.transaction(LOCAL_FILES_STORE, 'readwrite');
+    const store = transaction.objectStore(LOCAL_FILES_STORE);
+
+    return new Promise((resolve, reject) => {
+      const request = store.put(record);
+      request.onsuccess = () => {
+        db.close();
+        resolve(record);
+      };
+      request.onerror = () => {
+        db.close();
+        reject(new Error('创建本地文件失败'));
+      };
+    });
+  } catch (error) {
+    console.error('创建本地文件失败:', error);
+    throw error;
+  }
+}
+
+/**
+ * 为已上传的服务器文件保存本地未同步修改快照
+ */
+export async function saveUnsyncedServerFile(params: {
+  userId: string;
+  projectId: string;
+  parentId: string | null;
+  fileName: string;
+  fileType: FileType;
+  serverFileId: string;
+  originalServerFile: any;
+  content: ArrayBuffer | string;
+  /** 原始服务器文件内容（用于差分上传基准） */
+  originalContent?: ArrayBuffer | string;
+  markUnsynced?: boolean;
+}): Promise<LocalFileRecord> {
+  try {
+    // 先检查是否已经存在该 serverFileId 的未同步记录，存在则更新，不存在则新建
+    const existing = await getLocalFileByServerId(params.userId, params.serverFileId);
+    const now = Date.now();
+    const markUnsynced = params.markUnsynced ?? true;
+
+    const record: LocalFileRecord = existing ? {
+      ...existing,
+      fileName: params.fileName,
+      fileType: params.fileType,
+      parentId: params.parentId,
+      content: params.content,
+      fileSize: calculateContentSize(params.content),
+      hasUnsyncedChanges: markUnsynced,
+      originalServerFile: params.originalServerFile || existing.originalServerFile,
+      // 仅在首次创建时存储 originalContent，后续更新不覆盖
+      originalContent: existing.originalContent ?? params.originalContent,
+      updatedAt: now,
+    } : {
+      localId: generateLocalId(),
+      userId: params.userId,
+      projectId: params.projectId,
+      parentId: params.parentId,
+      fileName: params.fileName,
+      fileType: params.fileType,
+      serverFileId: params.serverFileId,
+      isLocalOnly: false,
+      hasUnsyncedChanges: markUnsynced,
+      originalServerFile: params.originalServerFile,
+      originalContent: params.originalContent,
+      content: params.content,
+      fileSize: calculateContentSize(params.content),
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    const db = await openDB();
+    const transaction = db.transaction(LOCAL_FILES_STORE, 'readwrite');
+    const store = transaction.objectStore(LOCAL_FILES_STORE);
+
+    return new Promise((resolve, reject) => {
+      const request = store.put(record);
+      request.onsuccess = () => {
+        db.close();
+        resolve(record);
+      };
+      request.onerror = () => {
+        db.close();
+        reject(new Error('保存本地未同步文件失败'));
+      };
+    });
+  } catch (error) {
+    console.error('保存本地未同步文件失败:', error);
+    throw error;
+  }
+}
+
+/**
+ * 更新本地文件内容（用户编辑后）
+ */
+export async function updateLocalFileContent(
+  localId: string,
+  content: ArrayBuffer | string,
+  fileName?: string,
+  markUnsynced: boolean = true
+): Promise<LocalFileRecord | null> {
+  try {
+    const record = await getLocalFile(localId);
+    if (!record) return null;
+
+    const updated: LocalFileRecord = {
+      ...record,
+      content,
+      fileSize: calculateContentSize(content),
+      fileName: fileName ?? record.fileName,
+      hasUnsyncedChanges: markUnsynced,
+      updatedAt: Date.now(),
+    };
+
+    const db = await openDB();
+    const transaction = db.transaction(LOCAL_FILES_STORE, 'readwrite');
+    const store = transaction.objectStore(LOCAL_FILES_STORE);
+
+    return new Promise((resolve, reject) => {
+      const request = store.put(updated);
+      request.onsuccess = () => {
+        db.close();
+        resolve(updated);
+      };
+      request.onerror = () => {
+        db.close();
+        reject(new Error('更新本地文件内容失败'));
+      };
+    });
+  } catch (error) {
+    console.error('更新本地文件内容失败:', error);
+    return null;
+  }
+}
+
+/**
+ * 获取单个本地文件记录
+ */
+export async function getLocalFile(localId: string): Promise<LocalFileRecord | null> {
+  try {
+    const db = await openDB();
+    const transaction = db.transaction(LOCAL_FILES_STORE, 'readonly');
+    const store = transaction.objectStore(LOCAL_FILES_STORE);
+
+    return new Promise((resolve, reject) => {
+      const request = store.get(localId);
+      request.onsuccess = () => {
+        db.close();
+        resolve(request.result || null);
+      };
+      request.onerror = () => {
+        db.close();
+        reject(new Error('获取本地文件失败'));
+      };
+    });
+  } catch (error) {
+    console.error('获取本地文件失败:', error);
+    return null;
+  }
+}
+
+/**
+ * 通过服务器文件 ID 查找对应的本地未同步记录
+ */
+export async function getLocalFileByServerId(userId: string, serverFileId: string): Promise<LocalFileRecord | null> {
+  try {
+    const db = await openDB();
+    const transaction = db.transaction(LOCAL_FILES_STORE, 'readonly');
+    const store = transaction.objectStore(LOCAL_FILES_STORE);
+    const index = store.index('userId_serverFileId');
+
+    return new Promise((resolve, reject) => {
+      const request = index.get([userId, serverFileId]);
+      request.onsuccess = () => {
+        db.close();
+        resolve(request.result || null);
+      };
+      request.onerror = () => {
+        db.close();
+        reject(new Error('查找本地未同步文件失败'));
+      };
+    });
+  } catch (error) {
+    console.error('查找本地未同步文件失败:', error);
+    return null;
+  }
+}
+
+/**
+ * 列出指定项目下所有本地文件（本地新文件 + 服务器文件未同步修改）
+ */
+export async function listLocalFilesByProject(userId: string, projectId: string): Promise<LocalFileRecord[]> {
+  try {
+    const db = await openDB();
+    const transaction = db.transaction(LOCAL_FILES_STORE, 'readonly');
+    const store = transaction.objectStore(LOCAL_FILES_STORE);
+    const index = store.index('userId_projectId');
+
+    return new Promise((resolve, reject) => {
+      const request = index.getAll([userId, projectId]);
+      request.onsuccess = () => {
+        db.close();
+        resolve(request.result || []);
+      };
+      request.onerror = () => {
+        db.close();
+        reject(new Error('列出本地文件失败'));
+      };
+    });
+  } catch (error) {
+    console.error('列出本地文件失败:', error);
+    return [];
+  }
+}
+
+/**
+ * 标记本地文件为已同步（上传成功后调用）。如果 isLocalOnly=true 则删除记录；否则保留但 hasUnsyncedChanges=false
+ */
+export async function markLocalFileSynced(localId: string, uploadedServerFileId?: string): Promise<void> {
+  try {
+    const record = await getLocalFile(localId);
+    if (!record) return;
+
+    const db = await openDB();
+    const transaction = db.transaction(LOCAL_FILES_STORE, 'readwrite');
+    const store = transaction.objectStore(LOCAL_FILES_STORE);
+
+    if (record.isLocalOnly) {
+      // 本地新文件上传成功 → 删除本地记录（因为现在服务器有了）
+      return new Promise((resolve, reject) => {
+        const request = store.delete(localId);
+        request.onsuccess = () => {
+          db.close();
+          resolve();
+        };
+        request.onerror = () => {
+          db.close();
+          reject(new Error('删除已上传本地文件记录失败'));
+        };
+      });
+    } else {
+      // 服务器文件的离线修改已同步 → 保留记录但标记已同步
+      const updated: LocalFileRecord = {
+        ...record,
+        hasUnsyncedChanges: false,
+        serverFileId: uploadedServerFileId || record.serverFileId,
+        updatedAt: Date.now(),
+      };
+      return new Promise((resolve, reject) => {
+        const request = store.put(updated);
+        request.onsuccess = () => {
+          db.close();
+          resolve();
+        };
+        request.onerror = () => {
+          db.close();
+          reject(new Error('标记同步失败'));
+        };
+      });
+    }
+  } catch (error) {
+    console.error('标记本地文件同步失败:', error);
+  }
+}
+
+/**
+ * 删除本地文件记录
+ */
+export async function deleteLocalFile(localId: string): Promise<void> {
+  try {
+    const db = await openDB();
+    const transaction = db.transaction(LOCAL_FILES_STORE, 'readwrite');
+    const store = transaction.objectStore(LOCAL_FILES_STORE);
+
+    return new Promise((resolve, reject) => {
+      const request = store.delete(localId);
+      request.onsuccess = () => {
+        db.close();
+        resolve();
+      };
+      request.onerror = () => {
+        db.close();
+        reject(new Error('删除本地文件失败'));
+      };
+    });
+  } catch (error) {
+    console.error('删除本地文件失败:', error);
+  }
+}