Anons79 Mini Shell

import * as XLSX from 'xlsx';

export interface SheetData {
  name: string;
  data: any[][];
  cols: any[];
}

export interface ExcelFile {
  name: string;
  size: number;
  lastModified: number;
  sheets: SheetData[];
  activeSheet: number;
}

export const parseExcelFile = (file: File): Promise<ExcelFile> => {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    
    reader.onload = (event) => {
      try {
        const data = new Uint8Array(event.target?.result as ArrayBuffer);
        const workbook = XLSX.read(data, { type: 'array' });
        
        const sheets: SheetData[] = workbook.SheetNames.map((name) => {
          const sheet = workbook.Sheets[name];
          const jsonData = XLSX.utils.sheet_to_json<any>(sheet, { header: 1 });
          
          // Get column info
          const range = XLSX.utils.decode_range(sheet['!ref'] || 'A1');
          const cols = Array(range.e.c - range.s.c + 1).fill(null).map((_, i) => ({
            key: i,
            width: getColumnWidth(jsonData, i),
          }));
          
          return {
            name,
            data: jsonData,
            cols,
          };
        });

        resolve({
          name: file.name,
          size: file.size,
          lastModified: file.lastModified,
          sheets,
          activeSheet: 0,
        });
      } catch (error) {
        reject(error);
      }
    };
    
    reader.onerror = (error) => reject(error);
    reader.readAsArrayBuffer(file);
  });
};

// Helper function to determine column width based on content
const getColumnWidth = (data: any[][], colIndex: number): number => {
  let maxWidth = 0;
  
  for (let i = 0; i < Math.min(100, data.length); i++) {
    const row = data[i];
    if (row && row[colIndex] !== undefined) {
      const content = String(row[colIndex]);
      maxWidth = Math.max(maxWidth, content.length);
    }
  }
  
  // Set reasonable bounds for column width
  return Math.min(Math.max(maxWidth * 8, 80), 300);
};

export const formatFileSize = (bytes: number): string => {
  if (bytes === 0) return '0 Bytes';
  
  const k = 1024;
  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
  const i = Math.floor(Math.log(bytes) / Math.log(k));
  
  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
};

export const formatDate = (timestamp: number): string => {
  return new Date(timestamp).toLocaleString();
};

export const downloadSheet = (data: SheetData, fileName: string, format: string): void => {
  const worksheet = XLSX.utils.aoa_to_sheet(data.data);
  const workbook = XLSX.utils.book_new();
  XLSX.utils.book_append_sheet(workbook, worksheet, data.name);
  
  let exportedFileName = fileName;
  if (!exportedFileName.includes('.')) {
    exportedFileName += '.' + format;
  }
  
  XLSX.writeFile(workbook, exportedFileName);
};