@bytechain.cn/colamd 1.5.0 → 1.5.1-beta.2

package/scripts/generate-icons.js

@@ -0,0 +1,102 @@
+const sharp = require('sharp');
+const path = require('path');
+const fs = require('fs');
+
+const rootDir = path.join(__dirname, '..');
+const svgPath = path.join(rootDir, 'resources', 'icon.svg');
+const androidResPath = path.join(rootDir, 'android', 'app', 'src', 'main', 'res');
+const iosAssetsPath = path.join(rootDir, 'ios', 'App', 'App', 'Assets.xcassets', 'AppIcon.appiconset');
+
+const androidIcons = [
+  { name: 'mipmap-mdpi/ic_launcher.png', size: 48 },
+  { name: 'mipmap-mdpi/ic_launcher_round.png', size: 48 },
+  { name: 'mipmap-hdpi/ic_launcher.png', size: 72 },
+  { name: 'mipmap-hdpi/ic_launcher_round.png', size: 72 },
+  { name: 'mipmap-xhdpi/ic_launcher.png', size: 96 },
+  { name: 'mipmap-xhdpi/ic_launcher_round.png', size: 96 },
+  { name: 'mipmap-xxhdpi/ic_launcher.png', size: 144 },
+  { name: 'mipmap-xxhdpi/ic_launcher_round.png', size: 144 },
+  { name: 'mipmap-xxxhdpi/ic_launcher.png', size: 192 },
+  { name: 'mipmap-xxxhdpi/ic_launcher_round.png', size: 192 },
+];
+
+const androidForegroundIcons = [
+  { name: 'mipmap-mdpi/ic_launcher_foreground.png', size: 108 },
+  { name: 'mipmap-hdpi/ic_launcher_foreground.png', size: 162 },
+  { name: 'mipmap-xhdpi/ic_launcher_foreground.png', size: 216 },
+  { name: 'mipmap-xxhdpi/ic_launcher_foreground.png', size: 324 },
+  { name: 'mipmap-xxxhdpi/ic_launcher_foreground.png', size: 432 },
+];
+
+const iosIcons = [
+  { name: 'AppIcon-512@2x.png', size: 1024 },
+];
+
+async function generateIcons() {
+  console.log('Generating icons from SVG...');
+  
+  for (const icon of androidIcons) {
+    const outputPath = path.join(androidResPath, icon.name);
+    const dir = path.dirname(outputPath);
+    
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    
+    await sharp(svgPath)
+      .resize(icon.size, icon.size)
+      .png()
+      .toFile(outputPath);
+    
+    console.log(`Generated: ${icon.name} (${icon.size}x${icon.size})`);
+  }
+  
+  console.log('\nGenerating adaptive icon foreground layers...');
+  
+  for (const icon of androidForegroundIcons) {
+    const outputPath = path.join(androidResPath, icon.name);
+    const dir = path.dirname(outputPath);
+    
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    
+    const iconSize = Math.round(icon.size * 0.67);
+    const padding = Math.round((icon.size - iconSize) / 2);
+    
+    await sharp(svgPath)
+      .resize(iconSize, iconSize)
+      .extend({
+        top: padding,
+        bottom: padding,
+        left: padding,
+        right: padding,
+        background: { r: 0, g: 0, b: 0, alpha: 0 },
+      })
+      .png()
+      .toFile(outputPath);
+    
+    console.log(`Generated: ${icon.name} (${icon.size}x${icon.size}, icon: ${iconSize}x${iconSize})`);
+  }
+  
+  console.log('\nGenerating iOS icons...');
+  
+  for (const icon of iosIcons) {
+    const outputPath = path.join(iosAssetsPath, icon.name);
+    
+    if (!fs.existsSync(iosAssetsPath)) {
+      fs.mkdirSync(iosAssetsPath, { recursive: true });
+    }
+    
+    await sharp(svgPath)
+      .resize(icon.size, icon.size)
+      .png()
+      .toFile(outputPath);
+    
+    console.log(`Generated: ${icon.name} (${icon.size}x${icon.size})`);
+  }
+  
+  console.log('\nDone!');
+}
+
+generateIcons().catch(console.error);

package/src/main/index.ts

@@ -1,7 +1,7 @@
 import { app, BrowserWindow, ipcMain, dialog, Menu, shell } from 'electron'
 import { join, basename, dirname, extname } from 'path'
-import { readFile, writeFile, readdir, copyFile, mkdir } from 'fs/promises'
-import { watch, FSWatcher, existsSync, readdirSync, readFileSync, createServer } from 'fs'
+import { readFile, writeFile, readdir, copyFile, mkdir, stat } from 'fs/promises'
+import { existsSync, readFileSync } from 'fs'
 import { IncomingMessage, ServerResponse } from 'http'
 import { createServer as createHttpServer } from 'http'
 
@@ -14,19 +14,10 @@ function ensureThemesDir(): void {
   }
 }
 
-async function scanCustomThemes(): Promise<string[]> {
-  try {
-    const files = await readdir(themesDir)
-    return files.filter(f => f.endsWith('.css')).sort()
-  } catch {
-    return []
-  }
-}
-
 // Per-window state
 interface WindowState {
   filePath: string | null
-  watcher: FSWatcher | null
+  watcher: ReturnType<typeof setInterval> | null
   isInternalSave: boolean
   debounceTimer: ReturnType<typeof setTimeout> | null
   agentState: 'idle' | 'active' | 'cooldown'
@@ -110,7 +101,7 @@ function suggestFileName(win: BrowserWindow, content?: string): string | undefin
 
 function stopWatching(state: WindowState): void {
   if (state.watcher) {
-    state.watcher.close()
+    clearInterval(state.watcher)
     state.watcher = null
   }
   if (state.agentCooldownTimer) {
@@ -152,28 +143,36 @@ function watchFile(win: BrowserWindow, state: WindowState): void {
   if (!state.filePath) return
   stopWatching(state)
   const filePath = state.filePath
-  state.watcher = watch(filePath, (eventType) => {
-    if (eventType !== 'change' || state.isInternalSave) return
-
-    // Agent activity detection
-    const now = Date.now()
-    const gap = now - state.lastExternalChange
-    state.lastExternalChange = now
-    if (gap > 0 && gap < 2000) {
-      transitionAgentState(win, state, 'active')
-    } else if (state.agentState === 'active') {
-      transitionAgentState(win, state, 'active') // reset cooldown timer
-    }
+  let lastMtime = 0
+
+  stat(filePath).then(s => { lastMtime = s.mtimeMs }).catch(() => {})
+
+  state.watcher = setInterval(() => {
+    if (state.isInternalSave) return
+    stat(filePath).then(s => {
+      if (s.mtimeMs === lastMtime) return
+      lastMtime = s.mtimeMs
+
+      // Agent activity detection
+      const now = Date.now()
+      const gap = now - state.lastExternalChange
+      state.lastExternalChange = now
+      if (gap > 0 && gap < 2000) {
+        transitionAgentState(win, state, 'active')
+      } else if (state.agentState === 'active') {
+        transitionAgentState(win, state, 'active') // reset cooldown timer
+      }
 
-    if (state.debounceTimer) clearTimeout(state.debounceTimer)
-    state.debounceTimer = setTimeout(() => {
-      readFile(filePath, 'utf-8')
-        .then((data) => {
-          if (!win.isDestroyed()) win.webContents.send('file-changed', resolveImagePaths(data, filePath))
-        })
-        .catch(() => {})
-    }, 100)
-  })
+      if (state.debounceTimer) clearTimeout(state.debounceTimer)
+      state.debounceTimer = setTimeout(() => {
+        readFile(filePath, 'utf-8')
+          .then((data) => {
+            if (!win.isDestroyed()) win.webContents.send('file-changed', resolveImagePaths(data, filePath))
+          })
+          .catch(() => {})
+      }, 100)
+    }).catch(() => {})
+  }, 500)
 }
 
 // Rewrite relative image paths in markdown to absolute file:// URLs
@@ -382,8 +381,9 @@ ipcMain.handle('save-export-file', async (event, dataUrl: string, defaultName: s
 ipcMain.handle('export-pdf', async (event) => {
   const win = getWinFromEvent(event)
   if (!win) return false
+  const defaultName = (suggestFileName(win) || 'colamd-print') + '.pdf'
   const result = await dialog.showSaveDialog(win, {
-    defaultPath: suggestFileName(win),
+    defaultPath: defaultName,
     filters: [{ name: 'PDF', extensions: ['pdf'] }]
   })
   if (result.canceled || !result.filePath) return false
@@ -392,11 +392,13 @@ ipcMain.handle('export-pdf', async (event) => {
     const cssKey = await win.webContents.insertCSS(
       'html, body { height: auto !important; overflow: visible !important; } #titlebar { display: none !important; } #editor { height: auto !important; overflow: visible !important; } #editor .ProseMirror { min-height: auto !important; } .mermaid-error { display: none !important; } .mermaid-loading { display: none !important; } svg .error-icon, svg .error-text { display: none !important; } .math-inline-raw, .math-block-raw, textarea.mermaid-source { display: none !important; }'
     )
-    const pdfData = await win.webContents.printToPDF({
-      marginType: 0,
-      printBackground: true,
-      pageSize: 'A4'
-    })
+    const pdfData = await Promise.race([
+      win.webContents.printToPDF({
+        printBackground: true,
+        pageSize: 'A4'
+      }),
+      new Promise<Buffer>((_, reject) => setTimeout(() => reject(new Error('PDF timeout')), 30000))
+    ])
     await win.webContents.removeInsertedCSS(cssKey)
     await writeFile(result.filePath, pdfData)
     return true
@@ -408,8 +410,9 @@ ipcMain.handle('export-pdf', async (event) => {
 ipcMain.handle('export-html', async (event, htmlContent: string) => {
   const win = getWinFromEvent(event)
   if (!win) return false
+  const defaultName = (suggestFileName(win) || 'colamd-export') + '.html'
   const result = await dialog.showSaveDialog(win, {
-    defaultPath: suggestFileName(win),
+    defaultPath: defaultName,
     filters: [{ name: 'HTML', extensions: ['html'] }]
   })
   if (result.canceled || !result.filePath) return false
@@ -652,7 +655,8 @@ ipcMain.handle('load-custom-theme', async (event) => {
     const destPath = join(themesDir, fileName)
     await copyFile(srcPath, destPath)
     const css = await readFile(destPath, 'utf-8')
-    buildMenu() // rebuild menu to include new theme
+    invalidateThemeCache()
+    await buildMenu() // rebuild menu to include new theme
     return { name: fileName, css }
   } catch {
     return null
@@ -677,18 +681,40 @@ ipcMain.handle('register-plugins', (_event, plugins: Array<{ id: string; name: s
     checked: p.enabled,
     click: () => sendToFocused('menu-toggle-plugin', p.id)
   }))
-  buildMenu()
+  void buildMenu()
   return true
 })
 
 ipcMain.handle('sync-plugin-state', (_event, id: string, enabled: boolean) => {
   const item = pluginMenuItems.find((p: any) => p.id === id)
   if (item) item.checked = enabled
-  buildMenu()
+  void buildMenu()
 })
 
 // Menu — targets the focused window
 
+let cachedThemeFiles: string[] = []
+let themeFilesValid = false
+
+function invalidateThemeCache(): void {
+  themeFilesValid = false
+}
+
+async function scanThemeFiles(): Promise<void> {
+  try {
+    const files = await readdir(themesDir)
+    cachedThemeFiles = files.filter(f => f.endsWith('.css')).sort()
+  } catch {
+    cachedThemeFiles = []
+  }
+  themeFilesValid = true
+}
+
+async function getCachedThemeFiles(): Promise<string[]> {
+  if (!themeFilesValid) await scanThemeFiles()
+  return cachedThemeFiles
+}
+
 function getFocusedWindow(): BrowserWindow | null {
   return BrowserWindow.getFocusedWindow()
 }
@@ -698,26 +724,23 @@ function sendToFocused(channel: string, ...args: unknown[]): void {
   if (win) win.webContents.send(channel, ...args)
 }
 
-function buildMenu(): void {
+async function buildMenu(): Promise<void> {
   const isMac = process.platform === 'darwin'
 
-  // Scan custom themes synchronously for menu building
   const customThemeItems: Electron.MenuItemConstructorOptions[] = []
-  try {
-    const files = readdirSync(themesDir).filter((f: string) => f.endsWith('.css')).sort()
-    for (const file of files) {
-      customThemeItems.push({
-        label: file.replace(/\.css$/, ''),
-        click: async () => {
-          try {
-            const css = await readFile(join(themesDir, file), 'utf-8')
-            sendToFocused('set-theme', `custom:${file}`)
-            sendToFocused('set-custom-css', css)
-          } catch { /* ignore */ }
-        }
-      })
-    }
-  } catch { /* themes dir may not exist yet */ }
+  const files = await getCachedThemeFiles()
+  for (const file of files) {
+    customThemeItems.push({
+      label: file.replace(/\.css$/, ''),
+      click: async () => {
+        try {
+          const css = await readFile(join(themesDir, file), 'utf-8')
+          sendToFocused('set-theme', `custom:${file}`)
+          sendToFocused('set-custom-css', css)
+        } catch { /* ignore */ }
+      }
+    })
+  }
 
   const themeSubmenu: Electron.MenuItemConstructorOptions[] = [
     { label: 'Light', click: () => sendToFocused('set-theme', 'light') },
@@ -842,9 +865,10 @@ function buildMenu(): void {
 
 // App lifecycle
 
-app.whenReady().then(() => {
+app.whenReady().then(async () => {
   ensureThemesDir()
-  buildMenu()
+  await scanThemeFiles()
+  await buildMenu()
 
   // Check command line args for file paths
   const args = process.argv.slice(app.isPackaged ? 1 : 2)

package/src/preload/index.d.ts

@@ -0,0 +1,51 @@
+export interface ElectronAPI {
+    openFile: () => Promise<{
+        path: string;
+        content: string;
+    } | null>;
+    openFilePath: (path: string) => Promise<{
+        path: string;
+        content: string;
+    } | null>;
+    saveFile: (content: string) => Promise<boolean>;
+    saveFileAs: (content: string) => Promise<boolean>;
+    exportPDF: () => Promise<boolean>;
+    exportHTML: (html: string) => Promise<boolean>;
+    newSlides: () => Promise<string | null>;
+    openAsSlides: (content: string) => Promise<boolean>;
+    loadCustomTheme: () => Promise<{
+        name: string;
+        css: string;
+    } | null>;
+    loadThemeCSS: (fileName: string) => Promise<string | null>;
+    getPathForFile: (file: File) => string;
+    openExternal: (url: string) => void;
+    onFileChanged: (callback: (content: string) => void) => void;
+    onNewFile: (callback: () => void) => void;
+    onFileOpened: (callback: (data: {
+        path: string;
+        content: string;
+    }) => void) => void;
+    onMenuOpen: (callback: () => void) => void;
+    onMenuSave: (callback: () => void) => void;
+    onMenuSaveAs: (callback: () => void) => void;
+    onMenuExportPDF: (callback: () => void) => void;
+    onMenuExportHTML: (callback: () => void) => void;
+    onMenuNewSlides: (callback: () => void) => void;
+    onMenuOpenAsSlides: (callback: () => void) => void;
+    onNewSlidesContent: (callback: (content: string) => void) => void;
+    onSetTheme: (callback: (theme: string) => void) => void;
+    onSetCustomCSS: (callback: (css: string) => void) => void;
+    exportSlides: (content: string) => Promise<boolean>;
+    onMenuExportSlides: (callback: () => void) => void;
+    onAgentActivity: (callback: (state: string) => void) => void;
+    registerPlugins: (plugins: Array<{
+        id: string;
+        name: string;
+        enabled: boolean;
+    }>) => Promise<boolean>;
+    syncPluginState: (id: string, enabled: boolean) => Promise<void>;
+    onMenuTogglePlugin: (callback: (id: string) => void) => void;
+    onMenuImportTheme: (callback: () => void) => void;
+    exportFile: (dataUrl: string, defaultName: string) => Promise<boolean>;
+}

package/src/preload/index.js

@@ -0,0 +1,70 @@
+import { contextBridge, ipcRenderer, webUtils } from 'electron';
+contextBridge.exposeInMainWorld('electronAPI', {
+    openFile: () => ipcRenderer.invoke('open-file'),
+    openFilePath: (path) => ipcRenderer.invoke('open-file-path', path),
+    saveFile: (content) => ipcRenderer.invoke('save-file', content),
+    saveFileAs: (content) => ipcRenderer.invoke('save-file-as', content),
+    exportPDF: () => ipcRenderer.invoke('export-pdf'),
+    exportHTML: (html) => ipcRenderer.invoke('export-html', html),
+    exportSlides: (content) => ipcRenderer.invoke('export-slides', content),
+    newSlides: () => ipcRenderer.invoke('new-slides'),
+    openAsSlides: (content) => ipcRenderer.invoke('open-as-slides', content),
+    loadCustomTheme: () => ipcRenderer.invoke('load-custom-theme'),
+    loadThemeCSS: (fileName) => ipcRenderer.invoke('load-theme-css', fileName),
+    getPathForFile: (file) => webUtils.getPathForFile(file),
+    openExternal: (url) => ipcRenderer.send('open-external', url),
+    onFileChanged: (callback) => {
+        ipcRenderer.on('file-changed', (_event, content) => callback(content));
+    },
+    onNewFile: (callback) => {
+        ipcRenderer.on('new-file', () => callback());
+    },
+    onFileOpened: (callback) => {
+        ipcRenderer.on('file-opened', (_event, data) => callback(data));
+    },
+    onMenuOpen: (callback) => {
+        ipcRenderer.on('menu-open', () => callback());
+    },
+    onMenuSave: (callback) => {
+        ipcRenderer.on('menu-save', () => callback());
+    },
+    onMenuSaveAs: (callback) => {
+        ipcRenderer.on('menu-save-as', () => callback());
+    },
+    onMenuExportPDF: (callback) => {
+        ipcRenderer.on('menu-export-pdf', () => callback());
+    },
+    onMenuExportHTML: (callback) => {
+        ipcRenderer.on('menu-export-html', () => callback());
+    },
+    onMenuNewSlides: (callback) => {
+        ipcRenderer.on('menu-new-slides', () => callback());
+    },
+    onMenuOpenAsSlides: (callback) => {
+        ipcRenderer.on('menu-open-as-slides', () => callback());
+    },
+    onNewSlidesContent: (callback) => {
+        ipcRenderer.on('new-slides-content', (_event, content) => callback(content));
+    },
+    onSetTheme: (callback) => {
+        ipcRenderer.on('set-theme', (_event, theme) => callback(theme));
+    },
+    onSetCustomCSS: (callback) => {
+        ipcRenderer.on('set-custom-css', (_event, css) => callback(css));
+    },
+    onMenuImportTheme: (callback) => {
+        ipcRenderer.on('menu-import-theme', () => callback());
+    },
+    onMenuExportSlides: (callback) => {
+        ipcRenderer.on('menu-export-slides', () => callback());
+    },
+    onAgentActivity: (callback) => {
+        ipcRenderer.on('agent-activity', (_event, state) => callback(state));
+    },
+    registerPlugins: (plugins) => ipcRenderer.invoke('register-plugins', plugins),
+    syncPluginState: (id, enabled) => ipcRenderer.invoke('sync-plugin-state', id, enabled),
+    onMenuTogglePlugin: (callback) => {
+        ipcRenderer.on('menu-toggle-plugin', (_event, id) => callback(id));
+    },
+    exportFile: (dataUrl, defaultName) => ipcRenderer.invoke('save-export-file', dataUrl, defaultName),
+});