@spacecorexdev/core 0.0.2 → 0.0.5

package/src/ui/UIFilePreview/ExcelEditor/index.tsx

@@ -0,0 +1,617 @@
+import React, { useEffect, useRef, useCallback, useState } from 'react';
+import { Modal, Button, Space, message, Popconfirm, Tag } from 'antd';
+import { SaveOutlined, FileExcelFilled, UploadOutlined, DeleteOutlined, CloseOutlined, CloudOutlined, CloudServerOutlined } from '@ant-design/icons';
+import { UniverSheetsCorePreset } from '@univerjs/preset-sheets-core';
+import UniverPresetSheetsCoreZhCN from '@univerjs/preset-sheets-core/locales/zh-CN';
+import { createUniver, LocaleType, mergeLocales, Univer } from '@univerjs/presets';
+import * as XLSX from 'xlsx';
+
+import '@univerjs/preset-sheets-core/lib/index.css';
+import { ArrowLeft } from 'lucide-react';
+import { saveFile, loadFile, deleteFile } from '../IndexedDBUtils';
+import { CacheUserInfo } from '../../../utils/CacheUserInfo';
+import uiConfirm from '../../UIConfirm';
+
+const SHEET_VALUE_CHANGE_COMMAND_IDS = new Set([
+  'sheet.mutation.set-range-values',
+  'sheet.mutation.move-range',
+  'sheet.mutation.remove-worksheet-merge',
+  'sheet.mutation.add-worksheet-merge',
+  'sheet.mutation.reorder-range',
+  'sheet.mutation.set-worksheet-default-style',
+  'sheet.mutation.set-row-data',
+  'sheet.mutation.set-col-data',
+  'sheet.mutation.set-worksheet-range-theme-style',
+  'sheet.mutation.remove-worksheet-range-theme-style',
+]);
+
+interface ExcelEditorProps {
+  visible: boolean;
+  hiddenClose?: boolean; // 是否隐藏关闭按钮
+  isCreate?: boolean; // 是否为新建模式 
+  onClose: () => void;
+  fileName: string;
+  onUpload?: (initialBlob:Blob|undefined, blob: Blob, fileName: string) => Promise<void>;
+  initialBlob?: Blob;
+  readOnly?: boolean;
+  uploadPercent?: number;
+  uploadSuccess?: boolean;
+  // ---- 新增：本地文件 / 离线模式支持 ----
+  isOffline?: boolean;
+  isLocalOnly?: boolean;
+  hasUnsyncedChanges?: boolean;
+  onSaveLocalBlob?: (blob: Blob, fileName: string, markUnsynced?: boolean) => Promise<void>;
+}
+
+export const ExcelEditor: React.FC<ExcelEditorProps> = ({ visible, hiddenClose = false, isCreate, onClose, fileName, onUpload, initialBlob, readOnly, uploadPercent, uploadSuccess, isOffline, isLocalOnly, hasUnsyncedChanges, onSaveLocalBlob }) => { 
+  const containerRef = useRef<HTMLDivElement>(null);
+  const univerRef = useRef<Univer | null>(null);
+  const univerAPIRef = useRef<any>(null);
+  const saveTimerRef = useRef<NodeJS.Timeout | null>(null);
+  const [userId, setUserId] = useState<string | null>(null);
+  const [initialWorkbookData, setInitialWorkbookData] = useState<any>(null);
+  const [editorKey, setEditorKey] = useState(0);
+  const [hasLocalCache, setHasLocalCache] = useState(false);
+  const [hasUploaded, setHasUploaded] = useState(!isCreate);
+  const [loadingInitialBlob, setLoadingInitialBlob] = useState(false);
+  // 跟踪"标记为未同步"的调用是否已在本次编辑会话中执行过，避免每次编辑都写 IndexedDB
+  const markUnsyncedTriggeredRef = useRef(false);
+  // 跟踪编辑器是否已完成初始加载。编辑器初始化时会触发 CommandExecuted，需抑制以免误标"有修改未同步"。
+  const isEditorReadyRef = useRef(false);
+  // 跟踪当前差分上传的基准 blob（即服务器上最新的文件内容）。
+  // 上传成功后会更新为本次上传的 blob，确保下次差分基准与服务器一致。
+  const baseBlobRef = useRef<Blob | undefined>(initialBlob);
+
+  // 用 ref 跟踪这些"状态标记"属性，避免它们的变化（如保存/上传后更新标记）
+  // 触发 Univer 初始化 useEffect 重新执行，导致编辑器销毁重建、画面闪动。
+  const hasUnsyncedChangesRef = useRef(hasUnsyncedChanges);
+  const onSaveLocalBlobRef = useRef(onSaveLocalBlob);
+  hasUnsyncedChangesRef.current = hasUnsyncedChanges;
+  onSaveLocalBlobRef.current = onSaveLocalBlob;
+
+  // 获取当前登录用户
+  useEffect(() => {
+    if (visible) {
+      const getUserId = async () => {
+        try {
+          const userInfo = CacheUserInfo.currentLocalUser();
+          if (userInfo?.id) {
+            setUserId(userInfo.id);
+          } else {
+            setUserId(null);
+          }
+        } catch (error) {
+          console.error('获取用户信息失败:', error);
+          setUserId(null);
+        }
+      };
+      getUserId();
+    }
+  }, [visible]);
+
+  // 加载初始文件
+  useEffect(() => {
+    const loadInitialFile = async () => {
+      if (visible && userId) {
+        // 如果有传入的 initialBlob，优先加载它
+        if (initialBlob) {
+          try {
+            setLoadingInitialBlob(true);
+                        
+            // 需求3：彻底移除旧缓存检查。既然有了 initialBlob，直接加载
+            // 使用 XLSX 读取 blob 并转换为 Univer 格式
+            const arrayBuffer = await initialBlob.arrayBuffer();
+            const workbook = XLSX.read(arrayBuffer);
+            
+            // 将 XLSX 格式转换为 Univer 工作簿格式
+            const univerWorkbookData: any = {
+              id: `workbook-${Date.now()}`, // 添加工作簿 ID
+              name: fileName,
+              sheets: {},
+              sheetOrder: [],
+              locale: 'zhCN',
+              appVersion: '0.10.2'
+            };
+            
+            workbook.SheetNames.forEach((sheetName) => {
+              const worksheet = workbook.Sheets[sheetName];
+              const sheetId = `sheet-${Date.now()}-${sheetName}`; // 生成唯一的工作表 ID
+              
+              // 使用 sheet_to_json 的 range 选项来获取所有单元格，包括空单元格
+              const jsonData = XLSX.utils.sheet_to_json(worksheet, { 
+                header: 1,
+                defval: '', // 为空单元格提供默认值
+                raw: false // 获取格式化后的值
+              });
+              
+              // 转换为 Univer 格式
+              univerWorkbookData.sheets[sheetId] = {
+                id: sheetId, // 添加工作表 ID
+                name: sheetName,
+                cellData: {},
+                rowData: {},
+                columnData: {},
+                rowCount: Math.max(jsonData.length, 100), // 设置合理的行数
+                columnCount: Math.max(...(jsonData as any[][]).map((row: any[]) => row?.length || 0), 20), // 设置合理的列数
+                defaultColumnWidth: 100,
+                defaultRowHeight: 25,
+                showGridlines: 1,
+                rowHeader: { width: 46 },
+                columnHeader: { height: 20 },
+              };
+              
+              // 填充单元格数据（使用嵌套对象结构）
+              (jsonData as any[][]).forEach((row: any[], rowIndex: number) => {
+                if (!univerWorkbookData.sheets[sheetId].cellData[rowIndex]) {
+                  univerWorkbookData.sheets[sheetId].cellData[rowIndex] = {};
+                }
+                
+                row.forEach((cellValue: any, colIndex: number) => {
+                  // 只保存非空值
+                  if (cellValue !== undefined && cellValue !== null && cellValue !== '') {
+                    univerWorkbookData.sheets[sheetId].cellData[rowIndex][colIndex] = {
+                      v: cellValue,
+                    };
+                  }
+                });
+              });
+              
+              univerWorkbookData.sheetOrder.push(sheetId);
+            });
+            
+            setInitialWorkbookData(univerWorkbookData);
+            setEditorKey((prev) => prev + 1);
+            setHasLocalCache(false);
+          } catch (error) {
+            console.error('加载文件失败:', error);
+            message.error('加载文件失败');
+            setInitialWorkbookData(null);
+            setHasLocalCache(false);
+          } finally {
+            setLoadingInitialBlob(false);
+          }
+        } else if (isCreate && fileName && userId) {
+          // 需求3：新建模式下不再自动检查/加载旧的本地缓存
+          // 新建的本地文件会通过 initialBlob 从 localFiles store 传入内容
+          // 没有 initialBlob 时（兜底），直接创建空白工作簿（univer 初始化时自动创建）
+          try {
+            setInitialWorkbookData(null);
+            setHasLocalCache(false);
+          } catch (error) {
+            console.error('创建新工作簿失败:', error);
+            setInitialWorkbookData(null);
+            setHasLocalCache(false);
+          }
+        } else {
+          // 没有用户ID，重置状态
+          setInitialWorkbookData(null);
+          setHasLocalCache(false);
+        }
+      }
+    };
+    
+    loadInitialFile();
+  }, [visible, fileName, userId, initialBlob, isCreate, readOnly]);
+
+  // 获取当前工作簿数据
+  const getWorkbookData = useCallback(() => {
+    if (!univerAPIRef.current) return null;
+    const workbook = univerAPIRef.current.getActiveWorkbook();
+    if (!workbook) return null;
+    return workbook.save(); // workbook.getSnapshot();
+  }, []);
+
+  // 提交正在编辑的单元格内容（在导出/保存前调用）
+  const commitCellEditor = useCallback(async (event?: React.MouseEvent<HTMLElement>): Promise<void> => {
+    // 阻止按钮获取焦点，避免编辑器在 endEditing 之前丢失焦点
+    if (event) {
+      event.preventDefault();
+      event.stopPropagation();
+    }
+
+    try {
+      const workbook = univerAPIRef.current?.getActiveWorkbook?.();
+      if (workbook && typeof (workbook as any).endEditingAsync === 'function') {
+        await (workbook as any).endEditingAsync(true);
+        console.log('[Excel] endEditingAsync(true) 完成');
+      } else if (workbook && typeof (workbook as any).endEditing === 'function') {
+        await (workbook as any).endEditing(true);
+        console.log('[Excel] endEditing(true) 完成');
+      }
+    } catch (err) {
+      console.warn('[Excel] 提交单元格编辑失败:', err);
+    }
+  }, []);
+
+  // 导出 Excel 文件为 Blob
+  const exportToBlob = useCallback(async (): Promise<Blob | null> => {
+    try {
+      if (!univerAPIRef.current) {
+        message.error('编辑器未初始化');
+        return null;
+      }
+
+      const workbook = univerAPIRef.current.getActiveWorkbook();
+      if (!workbook) {
+        message.error('没有可保存的工作簿');
+        return null;
+      }
+
+      // 提交正在编辑的单元格内容
+      await commitCellEditor();
+
+      // 使用 Univer API 获取快照数据
+      const snapshot = workbook.save();
+      
+      // 将 Univer 快照数据转换为 XLSX 格式
+      const xlsxWorkbook = XLSX.utils.book_new();
+      
+      // 遍历所有工作表
+      if (snapshot.sheets && snapshot.sheetOrder) {
+        snapshot.sheetOrder.forEach((sheetId: string) => {
+          const sheet = snapshot.sheets[sheetId];
+          if (!sheet) return;
+          
+          const sheetName = sheet.name || '工作表';
+          const cellData = sheet.cellData || {};
+          
+          // 转换单元格数据为二维数组
+          const data: any[][] = [];
+          
+          // 遍历所有行
+          Object.keys(cellData).forEach((rowKey: string) => {
+            const rowIndex = parseInt(rowKey);
+            const row = cellData[rowKey];
+            
+            // 确保数组有足够的行
+            while (data.length <= rowIndex) {
+              data.push([]);
+            }
+            
+            // 遍历所有列
+            Object.keys(row).forEach((colKey: string) => {
+              const colIndex = parseInt(colKey);
+              const cell = row[colKey];
+              
+              // 确保数组有足够的列
+              while (data[rowIndex].length <= colIndex) {
+                data[rowIndex].push('');
+              }
+              
+              // 设置单元格值
+              data[rowIndex][colIndex] = cell?.v || '';
+            });
+          });
+          
+          const worksheet = XLSX.utils.aoa_to_sheet(data);
+          XLSX.utils.book_append_sheet(xlsxWorkbook, worksheet, sheetName);
+        });
+      }
+
+      const excelBuffer = XLSX.write(xlsxWorkbook, { bookType: 'xlsx', type: 'array' });
+      return new Blob([excelBuffer], { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' });
+    } catch (error) {
+      console.error('导出 Excel 失败:', error);
+      return null;
+    }
+  }, []);
+
+  // 自动保存到 IndexedDB（防抖）+ 同步 localFiles store
+  const autoSaveToIndexedDB = useCallback(() => {
+    if (!fileName || !userId) return;
+
+    const data = getWorkbookData();
+    if (!data) return;
+
+    if (saveTimerRef.current) {
+      clearTimeout(saveTimerRef.current);
+    }
+
+    saveTimerRef.current = setTimeout(async () => {
+      try {
+        await saveFile(userId, fileName, 'xlsx', data);
+        setHasLocalCache(false);
+        // 同步更新 localFiles store，确保自动保存也持久化到 localFiles
+        const fn = onSaveLocalBlobRef.current;
+        if (fn) {
+          try {
+            const blob = await exportToBlob();
+            if (blob) {
+              await fn(blob, fileName, false);
+            }
+          } catch (err) {
+            console.warn('自动保存时同步 localFiles store 失败（不影响本地保存）:', err);
+          }
+        }
+      } catch (error) {
+        console.error('自动保存到 IndexedDB 失败:', error);
+      }
+    }, 20000);
+  }, [fileName, userId, getWorkbookData, exportToBlob]);
+
+  // 初始化 Univer
+  useEffect(() => {
+    if (!visible || !containerRef.current) return;
+
+    // 清理之前的实例
+    if (univerAPIRef.current) {
+      univerAPIRef.current.dispose();
+      univerAPIRef.current = null;
+      univerRef.current = null;
+    }
+
+    // 创建 Univer 实例
+    const { univer, univerAPI } = createUniver({
+      locale: LocaleType.ZH_CN,
+      locales: {
+        [LocaleType.ZH_CN]: mergeLocales(UniverPresetSheetsCoreZhCN),
+      },
+      presets: [
+        UniverSheetsCorePreset({
+          container: containerRef.current,
+        }),
+      ],
+    });
+
+    univerRef.current = univer;
+    univerAPIRef.current = univerAPI;
+
+    // 创建或加载工作簿
+    if (initialWorkbookData) {
+      try {
+        univerAPI.createWorkbook(initialWorkbookData);
+      } catch (e) {
+        univerAPI.createWorkbook({ name: fileName });
+      }
+    } else {
+      univerAPI.createWorkbook({ name: fileName });
+    }
+
+    // 监听工作簿内容变化，只有真实编辑内容变化时才标记未保存并触发防抖保存。
+    const valueChangeDisposable = univerAPI.addEvent(univerAPI.Event.CommandExecuted, ({ id }: { id: string }) => {
+      if (readOnly || !SHEET_VALUE_CHANGE_COMMAND_IDS.has(id)) return;
+      // 抑制编辑器初始化期间触发的 CommandExecuted，避免误标"有修改未同步"
+      if (!isEditorReadyRef.current) return;
+
+      setHasLocalCache(true);
+      setHasUploaded(false);
+      autoSaveToIndexedDB();
+
+      // 首次编辑（且 hasUnsyncedChanges 目前为 false）时，立即标记未同步。
+      // 上传成功后 hasUnsyncedChanges 被清除，用户继续编辑后应立即重新显示"有未同步修改"。
+      if (!markUnsyncedTriggeredRef.current && !hasUnsyncedChangesRef.current && onSaveLocalBlobRef.current) {
+        markUnsyncedTriggeredRef.current = true;
+        const fn = onSaveLocalBlobRef.current;
+        (async () => {
+          try {
+            const blob = await exportToBlob();
+            if (blob) {
+              await fn(blob, fileName);
+            } else {
+              markUnsyncedTriggeredRef.current = false;
+            }
+          } catch (err) {
+            markUnsyncedTriggeredRef.current = false;
+            console.warn('编辑时立即标记未同步失败（不影响编辑，等待自动/手动保存即可）:', err);
+          }
+        })();
+      }
+    });
+
+    return () => {
+      valueChangeDisposable.dispose();
+      if (univerAPIRef.current) {
+        univerAPIRef.current.dispose();
+        univerAPIRef.current = null;
+        univerRef.current = null;
+      }
+    };
+  }, [visible, fileName, initialWorkbookData, editorKey, autoSaveToIndexedDB, readOnly, exportToBlob]);
+
+  // 编辑器初始化后，延迟标记为"就绪"，让初始化期间的 CommandExecuted 事件先过去
+  useEffect(() => {
+    if (!visible || loadingInitialBlob) return;
+    const timer = setTimeout(() => {
+      isEditorReadyRef.current = true;
+    }, 2000);
+    return () => {
+      clearTimeout(timer);
+      isEditorReadyRef.current = false;
+    };
+  }, [editorKey, visible, loadingInitialBlob]);
+
+  // initialBlob 变化时（文件切换/加载）重置差分基准
+  useEffect(() => {
+    baseBlobRef.current = initialBlob;
+  }, [initialBlob]);
+
+  // 保存到 IndexedDB
+  const handleSave = useCallback(async () => {
+    try {
+      const data = getWorkbookData();
+      if (!data) {
+        message.error('编辑器未初始化');
+        return;
+      }
+      if (!userId) {
+        message.error('无法获取用户信息');
+        return;
+      }
+
+      await saveFile(userId, fileName, 'xlsx', data);
+      setHasLocalCache(false);
+
+      // 通知父组件更新 localFiles store（需同时导出为 blob）
+      if (onSaveLocalBlob) {
+        try {
+          const blob = await exportToBlob();
+          if (blob) {
+            await onSaveLocalBlob(blob, fileName, false);
+          }
+        } catch (err) {
+          console.warn('同步本地文件内容到 localFiles store 失败（不影响本地保存）:', err);
+        }
+      }
+
+      message.success('已保存到本地缓存');
+    } catch (error) {
+      console.error('保存到本地缓存失败:', error);
+      message.error('保存失败');
+    }
+  }, [fileName, userId, getWorkbookData, exportToBlob, onSaveLocalBlob]);
+
+  // 上传到服务器
+  const handleUpload = useCallback(async () => {
+    if (!onUpload) {
+      message.error('未提供上传功能');
+      return;
+    }
+    try {
+      const blob = await exportToBlob();
+      if (!blob) return;
+
+      // 使用 baseBlobRef 作为差分基准，而非 initialBlob。
+      // 上传成功后 baseBlobRef 会更新为本次上传的 blob，确保下次差分基准与服务端一致。
+      const baseBlob = baseBlobRef.current ?? initialBlob;
+      await onUpload(baseBlob, blob, fileName);
+
+      // 上传成功后更新差分基准，使下次上传的差分基准与服务器一致
+      baseBlobRef.current = blob;
+
+      // 上传成功后，清空本地缓存
+      if (userId) {
+        await deleteFile(userId, fileName, 'xlsx');
+        setHasLocalCache(false);
+        setHasUploaded(true);
+      }
+      // 上传成功后重置"立即标记未同步"触发器，使后续编辑可再次立即触发
+      markUnsyncedTriggeredRef.current = false;
+    } catch (error) {
+      console.error('上传失败:', error);
+      message.error('上传失败');
+    }
+  }, [fileName, onUpload, exportToBlob, userId, initialBlob]);
+
+  // Ctrl+S / Cmd+S 保存到本地缓存
+  useEffect(() => {
+    if (!visible) return;
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if ((e.ctrlKey || e.metaKey) && e.key === 's') {
+        e.preventDefault();
+        handleSave();
+      }
+    };
+    window.addEventListener('keydown', handleKeyDown);
+    return () => window.removeEventListener('keydown', handleKeyDown);
+  }, [visible, handleSave]);
+
+  // 重置状态和清理定时器（当编辑器打开/关闭时）
+  useEffect(() => {
+    if (visible) {
+      setHasUploaded(!isCreate);
+      // 重置"立即标记未同步"触发器
+      markUnsyncedTriggeredRef.current = false;
+      // 清理之前的定时器
+      if (saveTimerRef.current) {
+        clearTimeout(saveTimerRef.current);
+        saveTimerRef.current = null;
+      }
+    }
+
+    // 组件卸载时清理定时器
+    return () => {
+      if (saveTimerRef.current) {
+        clearTimeout(saveTimerRef.current);
+        saveTimerRef.current = null;
+      }
+    };
+  }, [visible, isCreate]);
+
+  return (
+    <Modal
+      open={visible}
+      onCancel={onClose}
+      keyboard={false}
+      closeIcon={null}
+      footer={null}
+      style={{ top: 0, maxWidth: '100vw' }}
+      styles={{
+        body: {
+          height: '100dvh',
+          padding: 0,
+        },
+      }}
+      className="ant-modal-nopadding ant-modal-fullscreen"
+      transitionName='none'
+    >
+      <div className="h-full flex flex-col bg-white p-0 m-0">
+        {/* 工具栏 */}
+        <div className={`flex items-center justify-between px-4 py-2 pr-0 border-b flex-shrink-0 ${isOffline ? 'bg-orange-50 border-orange-200' : 'bg-gray-50 border-gray-200'}`}>
+          {/* 只读模式下直接关闭，不需要提示保存 */}
+          <span>&nbsp;</span>
+          {!readOnly && <span>&nbsp;</span>}
+          <div className="flex items-center gap-2 flex-wrap min-w-[40%]">
+            {!isOffline && isLocalOnly && (
+              <Tag icon={<CloudOutlined />} color="orange" style={{ margin: 0 }}>
+                本地文件
+              </Tag>
+            )}
+            {!isOffline && !isLocalOnly && hasUnsyncedChanges && (
+              <Tag icon={<CloudOutlined />} color="warning" style={{ margin: 0 }}>
+                有未同步修改
+              </Tag>
+            )}
+            {!isOffline && !isLocalOnly && !hasUnsyncedChanges && !onUpload ? (
+              <Tag icon={<CloudServerOutlined />} color="default" style={{ margin: 0 }}>
+                同步完成
+              </Tag>
+            ) : null}
+            <FileExcelFilled className="text-green-600" />
+            <span className="text-sm font-medium">{hasLocalCache ? '*' : ''}{fileName}</span>
+          </div>
+          {!readOnly && !hiddenClose && (
+            <Space wrap={true} align="center" direction="horizontal">
+              {/* <Button icon={<DeleteOutlined />} onClick={handleClearCache}>
+                清除缓存
+              </Button> */}
+              {onUpload && (
+                <Button type="text" style={{ paddingLeft: 4, paddingRight: 4 }} title="每次上传将保留一个历史版本，最多保留10个版本" icon={<UploadOutlined />} onMouseDown={commitCellEditor} onClick={handleUpload} disabled={uploadPercent !== undefined && uploadPercent < 1}>
+                  {uploadPercent !== undefined && uploadPercent < 1 ? `上传中 ${Math.round(uploadPercent * 100)}%` : '上传'}
+                </Button>
+              )}
+              <Button type="primary" icon={<SaveOutlined />} onMouseDown={commitCellEditor} onClick={handleSave}>
+                保存
+              </Button>
+              {(!readOnly && (hasLocalCache || !hasUploaded)) ?
+                (<Popconfirm
+                  title="确定要退出吗？"
+                  description={hasLocalCache?"修改未保存，确定要退出吗？": "修改未上传，确定要退出吗？"}
+                  onConfirm={onClose}
+                  okText="确定"
+                  cancelText="取消"
+                >
+                  <Button type="text" className="ml-3 mr-2" icon={<CloseOutlined className="w-6 h-6" />} />
+                </Popconfirm>) : (<CloseOutlined onClick={onClose} className='ml-3 mr-2 w-6 h-6'/>)}
+            </Space>
+          )}
+          {readOnly && !hiddenClose && (
+            <CloseOutlined onClick={onClose} className='ml-3 mr-2 w-6 h-6'/>)
+          }
+          {hiddenClose && <span>&nbsp;</span>}
+        </div>
+
+        {/* Univer 编辑器容器 */}
+        <div className="relative flex-1 min-h-0">
+          <div
+            key={editorKey}
+            ref={containerRef}
+            className="h-full univer-container overflow-hidden"
+            style={{ height: 'calc(100vh - 48px)' }}
+          />
+        </div>
+      </div>
+    </Modal>
+  );
+};
+
+export default ExcelEditor;

package/src/ui/UIFilePreview/ExcelEditor/types.ts

@@ -0,0 +1,24 @@
+export interface ExcelEditorProps {
+  visible: boolean;
+  onClose: () => void;
+  fileName: string;
+}
+
+export interface ExcelCell {
+  value: string | number | boolean | null;
+  formula?: string;
+}
+
+export interface ExcelSheet {
+  name: string;
+  data: ExcelCell[][];
+  colWidths: number[];
+  rowHeights: number[];
+}
+
+export interface ExcelEditorState {
+  sheets: ExcelSheet[];
+  currentSheetIndex: number;
+  selectedCell: { row: number; col: number } | null;
+  selectedRange: { startRow: number; startCol: number; endRow: number; endCol: number } | null;
+}