feat: Implement conversion history, persistent settings, and image conversion capabilities.

Author: utmp

bun.lock

@@ -1,18 +1,42 @@
-import { contextBridge as t, ipcRenderer as e } from "electron";
-t.exposeInMainWorld("electronAPI", {
+import { contextBridge, ipcRenderer } from "electron";
+contextBridge.exposeInMainWorld("electronAPI", {
   // Window controls
-  minimize: () => e.send("window-minimize"),
-  maximize: () => e.send("window-maximize"),
-  close: () => e.send("window-close"),
-  toggleDevTools: () => e.send("toggle-dev-tools"),
+  minimize: () => ipcRenderer.send("window-minimize"),
+  maximize: () => ipcRenderer.send("window-maximize"),
+  close: () => ipcRenderer.send("window-close"),
+  toggleDevTools: () => ipcRenderer.send("toggle-dev-tools"),
   // Window state listener
-  onMaximizeChange: (i) => {
-    const n = (d, o) => i(o);
-    return e.on("window-maximized-changed", n), () => e.removeListener("window-maximized-changed", n);
+  onMaximizeChange: (callback) => {
+    const handler = (_event, isMaximized) => callback(isMaximized);
+    ipcRenderer.on("window-maximized-changed", handler);
+    return () => ipcRenderer.removeListener("window-maximized-changed", handler);
   },
   // File operations
-  openFileDialog: () => e.invoke("open-file-dialog"),
-  selectOutputDir: () => e.invoke("select-output-dir"),
-  getFileInfo: (i) => e.invoke("get-file-info", i),
-  convertFiles: (i) => e.invoke("convert-files", i)
+  openFileDialog: () => ipcRenderer.invoke("open-file-dialog"),
+  selectOutputDir: () => ipcRenderer.invoke("select-output-dir"),
+  getFileInfo: (filePath) => ipcRenderer.invoke("get-file-info", filePath),
+  // Conversion
+  convertFiles: (payload) => ipcRenderer.invoke("convert-files", payload),
+  onConversionProgress: (callback) => {
+    const handler = (_event, data) => callback(data);
+    ipcRenderer.on("conversion-progress", handler);
+    return () => ipcRenderer.removeListener("conversion-progress", handler);
+  },
+  // Thumbnails
+  generateThumbnail: (filePath) => ipcRenderer.invoke("generate-thumbnail", filePath),
+  // History
+  getHistory: (options) => ipcRenderer.invoke("get-history", options),
+  getHistoryStats: () => ipcRenderer.invoke("get-history-stats"),
+  deleteHistoryItem: (id) => ipcRenderer.invoke("delete-history-item", id),
+  clearHistory: () => ipcRenderer.invoke("clear-history"),
+  showInFolder: (filePath) => ipcRenderer.invoke("show-in-folder", filePath),
+  // Settings
+  getSettings: () => ipcRenderer.invoke("get-settings"),
+  getSetting: (key) => ipcRenderer.invoke("get-setting", key),
+  updateSetting: (key, value) => ipcRenderer.invoke("update-setting", key, value),
+  resetSettings: () => ipcRenderer.invoke("reset-settings"),
+  // Utility
+  getAppVersion: () => ipcRenderer.invoke("get-app-version"),
+  getAppPath: (name) => ipcRenderer.invoke("get-app-path", name),
+  openExternal: (url) => ipcRenderer.invoke("open-external", url)
 });

dist-electron/main.js

@@ -0,0 +1,251 @@
+import sharp from 'sharp'
+import path from 'path'
+import fs from 'fs/promises'
+
+export interface ImageConvertOptions {
+    sourcePath: string
+    outputDir: string
+    targetFormat: string
+    quality: number          // 1-100
+    overwriteBehavior: 'skip' | 'rename' | 'overwrite'
+}
+
+export interface ConvertResult {
+    success: boolean
+    outputPath: string
+    error?: string
+    durationMs: number
+}
+
+// Formats natively supported by Sharp
+const SHARP_FORMATS = ['png', 'jpg', 'jpeg', 'webp', 'gif', 'avif', 'tiff', 'tif', 'jxl'] as const
+
+// Formats we can read but need special handling
+const SPECIAL_INPUT_FORMATS = ['svg', 'ico', 'bmp'] as const
+
+/**
+ * Check if a format is supported by our image converter
+ */
+export function isImageFormat(ext: string): boolean {
+    const lower = ext.toLowerCase()
+    return [...SHARP_FORMATS, ...SPECIAL_INPUT_FORMATS].includes(lower as typeof SHARP_FORMATS[number] | typeof SPECIAL_INPUT_FORMATS[number])
+}
+
+/**
+ * Generate a unique output file path, handling conflicts based on overwrite behavior.
+ */
+async function resolveOutputPath(
+    outputDir: string,
+    baseName: string,
+    targetFormat: string,
+    overwriteBehavior: 'skip' | 'rename' | 'overwrite'
+): Promise<{ path: string; skip: boolean }> {
+    const ext = targetFormat === 'jpg' ? 'jpg' : targetFormat
+    const outputPath = path.join(outputDir, `${baseName}.${ext}`)
+
+    try {
+        await fs.access(outputPath)
+        // File exists
+        if (overwriteBehavior === 'overwrite') {
+            return { path: outputPath, skip: false }
+        }
+        if (overwriteBehavior === 'skip') {
+            return { path: outputPath, skip: true }
+        }
+        // rename: find next available name
+        let counter = 1
+        let newPath: string
+        do {
+            newPath = path.join(outputDir, `${baseName} (${counter}).${ext}`)
+            counter++
+            try {
+                await fs.access(newPath)
+            } catch {
+                // File doesn't exist, use this path
+                return { path: newPath, skip: false }
+            }
+        } while (counter < 10000)
+
+        return { path: newPath, skip: false }
+    } catch {
+        // File doesn't exist, use original path
+        return { path: outputPath, skip: false }
+    }
+}
+
+/**
+ * Get the base name of a file without its extension
+ */
+function getBaseName(filePath: string): string {
+    const name = path.basename(filePath)
+    const lastDot = name.lastIndexOf('.')
+    if (lastDot === -1) return name
+    return name.substring(0, lastDot)
+}
+
+/**
+ * Convert an image file to the target format using Sharp.
+ */
+export async function convertImage(options: ImageConvertOptions): Promise<ConvertResult> {
+    const startTime = Date.now()
+    const { sourcePath, outputDir, targetFormat, quality, overwriteBehavior } = options
+
+    try {
+        // Validate source file exists
+        await fs.access(sourcePath)
+
+        // Ensure output directory exists
+        await fs.mkdir(outputDir, { recursive: true })
+
+        // Resolve output path
+        const baseName = getBaseName(sourcePath)
+        const { path: outputPath, skip } = await resolveOutputPath(
+            outputDir,
+            baseName,
+            targetFormat,
+            overwriteBehavior
+        )
+
+        if (skip) {
+            return {
+                success: true,
+                outputPath,
+                durationMs: Date.now() - startTime,
+            }
+        }
+
+        // Create Sharp pipeline
+        let pipeline = sharp(sourcePath, {
+            animated: false, // Don't process animated frames for conversion
+            failOn: 'none',  // Don't fail on minor image issues
+        })
+
+        // Apply format-specific conversion
+        const format = targetFormat.toLowerCase()
+        switch (format) {
+            case 'png':
+                pipeline = pipeline.png({
+                    quality,
+                    compressionLevel: quality >= 90 ? 6 : quality >= 60 ? 7 : 9,
+                })
+                break
+
+            case 'jpg':
+            case 'jpeg':
+                pipeline = pipeline.jpeg({
+                    quality,
+                    mozjpeg: true, // Better compression
+                })
+                break
+
+            case 'webp':
+                pipeline = pipeline.webp({
+                    quality,
+                    lossless: quality >= 100,
+                })
+                break
+
+            case 'avif':
+                pipeline = pipeline.avif({
+                    quality,
+                    lossless: quality >= 100,
+                })
+                break
+
+            case 'gif':
+                pipeline = pipeline.gif()
+                break
+
+            case 'tiff':
+            case 'tif':
+                pipeline = pipeline.tiff({
+                    quality,
+                    compression: 'lzw',
+                })
+                break
+
+            case 'jxl':
+                pipeline = pipeline.jxl({
+                    quality,
+                    lossless: quality >= 100,
+                })
+                break
+
+            case 'bmp':
+                // Sharp doesn't support BMP output natively;
+                // convert to PNG as a raw bitmap alternative
+                pipeline = pipeline.png({ compressionLevel: 0 })
+                break
+
+            case 'ico':
+                // ICO: resize to 256x256 max, output as PNG (common ICO approach)
+                pipeline = pipeline
+                    .resize(256, 256, { fit: 'inside', withoutEnlargement: true })
+                    .png()
+                break
+
+            case 'pdf':
+                // For image-to-PDF: not supported by Sharp alone
+                // We would need a separate PDF library
+                return {
+                    success: false,
+                    outputPath: '',
+                    error: 'Image to PDF conversion is not yet supported. A document converter is required.',
+                    durationMs: Date.now() - startTime,
+                }
+
+            default:
+                return {
+                    success: false,
+                    outputPath: '',
+                    error: `Unsupported target format: ${format}`,
+                    durationMs: Date.now() - startTime,
+                }
+        }
+
+        // Execute conversion
+        await pipeline.toFile(outputPath)
+
+        return {
+            success: true,
+            outputPath,
+            durationMs: Date.now() - startTime,
+        }
+    } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err)
+        console.error(`[image-converter] Failed to convert ${sourcePath}:`, errorMessage)
+
+        return {
+            success: false,
+            outputPath: '',
+            error: errorMessage,
+            durationMs: Date.now() - startTime,
+        }
+    }
+}
+
+/**
+ * Generate a thumbnail for an image file.
+ * Returns a base64 data URL.
+ */
+export async function generateThumbnail(
+    filePath: string,
+    size: number = 128
+): Promise<string | null> {
+    try {
+        const buffer = await sharp(filePath, {
+            failOn: 'none',
+        })
+            .resize(size, size, {
+                fit: 'cover',
+                position: 'centre',
+            })
+            .png({ quality: 70, compressionLevel: 9 })
+            .toBuffer()
+
+        return `data:image/png;base64,${buffer.toString('base64')}`
+    } catch (err) {
+        console.error(`[image-converter] Failed to generate thumbnail for ${filePath}:`, err)
+        return null
+    }
+}

dist-electron/preload.js

@@ -0,0 +1,30 @@
+export { convertImage, isImageFormat, generateThumbnail } from './image-converter'
+export type { ImageConvertOptions, ConvertResult } from './image-converter'
+
+// Category detection for routing to the right converter
+export type ConverterCategory = 'image' | 'document' | 'video' | 'audio'
+
+const IMAGE_FORMATS = new Set([
+    'png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'avif', 'tiff', 'tif', 'svg', 'ico', 'jxl',
+])
+
+const DOCUMENT_FORMATS = new Set([
+    'pdf', 'epub', 'xps', 'cbz', 'mobi', 'fb2', 'docx', 'txt', 'rtf', 'odt',
+])
+
+const VIDEO_FORMATS = new Set([
+    'mp4', 'mkv', 'avi', 'mov', 'webm', '3gp', 'flv', 'wmv',
+])
+
+const AUDIO_FORMATS = new Set([
+    'mp3', 'wav', 'aac', 'ogg', 'flac', 'wma', 'm4a',
+])
+
+export function getConverterCategory(ext: string): ConverterCategory | null {
+    const lower = ext.toLowerCase()
+    if (IMAGE_FORMATS.has(lower)) return 'image'
+    if (DOCUMENT_FORMATS.has(lower)) return 'document'
+    if (VIDEO_FORMATS.has(lower)) return 'video'
+    if (AUDIO_FORMATS.has(lower)) return 'audio'
+    return null
+}