434 lines
14 KiB
JavaScript
434 lines
14 KiB
JavaScript
var __defProp = Object.defineProperty;
|
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
|
|
|
|
// electron/main.ts
|
|
import { app, BrowserWindow as BrowserWindow3, shell, ipcMain, dialog as dialog2, nativeTheme, globalShortcut, clipboard } from "electron";
|
|
import path2 from "path";
|
|
import { fileURLToPath, pathToFileURL } from "url";
|
|
import fs2 from "fs";
|
|
import log2 from "electron-log";
|
|
|
|
// electron/services/pdfGenerator.ts
|
|
import { BrowserWindow } from "electron";
|
|
async function generatePdf(htmlContent) {
|
|
const printWin = new BrowserWindow({
|
|
show: false,
|
|
webPreferences: {
|
|
nodeIntegration: false,
|
|
contextIsolation: true,
|
|
sandbox: false
|
|
// 与 main.ts 保持一致，确保脚本执行权限
|
|
}
|
|
});
|
|
try {
|
|
await printWin.loadURL(`data:text/html;charset=utf-8,${encodeURIComponent(htmlContent)}`);
|
|
await printWin.webContents.executeJavaScript(`
|
|
new Promise(resolve => {
|
|
const check = () => {
|
|
if (window.__PRINT_READY__) {
|
|
resolve();
|
|
} else {
|
|
setTimeout(check, 100);
|
|
}
|
|
}
|
|
check();
|
|
})
|
|
`);
|
|
const pdfData = await printWin.webContents.printToPDF({
|
|
printBackground: true,
|
|
pageSize: "A4",
|
|
margins: { top: 0, bottom: 0, left: 0, right: 0 }
|
|
});
|
|
return pdfData;
|
|
} finally {
|
|
printWin.close();
|
|
}
|
|
}
|
|
|
|
// electron/services/htmlImport.ts
|
|
import { dialog } from "electron";
|
|
import path from "path";
|
|
import fs from "fs";
|
|
import log from "electron-log";
|
|
var selectHtmlFile = async (win) => {
|
|
if (!win) return { success: false, error: "No window found" };
|
|
try {
|
|
const { filePaths, canceled } = await dialog.showOpenDialog(win, {
|
|
title: "\u9009\u62E9 HTML \u6587\u4EF6",
|
|
filters: [
|
|
{ name: "HTML Files", extensions: ["html", "htm"] }
|
|
],
|
|
properties: ["openFile"]
|
|
});
|
|
if (canceled || filePaths.length === 0) {
|
|
return { success: false, canceled: true };
|
|
}
|
|
const htmlPath = filePaths[0];
|
|
const htmlDir = path.dirname(htmlPath);
|
|
const htmlFileName = path.basename(htmlPath, path.extname(htmlPath));
|
|
const assetsDirName = `${htmlFileName}_files`;
|
|
const assetsDirPath = path.join(htmlDir, assetsDirName);
|
|
const assetsFiles = [];
|
|
if (fs.existsSync(assetsDirPath)) {
|
|
const collectFiles = (dir, baseDir) => {
|
|
const entries = fs.readdirSync(dir, { withFileTypes: true });
|
|
for (const entry of entries) {
|
|
const fullPath = path.join(dir, entry.name);
|
|
if (entry.isDirectory()) {
|
|
collectFiles(fullPath, baseDir);
|
|
} else {
|
|
const relPath = path.relative(baseDir, fullPath);
|
|
assetsFiles.push(relPath);
|
|
}
|
|
}
|
|
};
|
|
collectFiles(assetsDirPath, assetsDirPath);
|
|
}
|
|
return {
|
|
success: true,
|
|
htmlPath,
|
|
htmlDir,
|
|
htmlFileName,
|
|
assetsDirName,
|
|
assetsFiles
|
|
};
|
|
} catch (error) {
|
|
log.error("Select HTML file failed:", error);
|
|
return { success: false, error: error.message };
|
|
}
|
|
};
|
|
|
|
// electron/state.ts
|
|
var ElectronState = class {
|
|
constructor() {
|
|
__publicField(this, "state", {
|
|
mainWindow: null,
|
|
serverPort: 3001,
|
|
isDev: false
|
|
});
|
|
}
|
|
getMainWindow() {
|
|
return this.state.mainWindow;
|
|
}
|
|
setMainWindow(window) {
|
|
this.state.mainWindow = window;
|
|
}
|
|
getServerPort() {
|
|
return this.state.serverPort;
|
|
}
|
|
setServerPort(port) {
|
|
this.state.serverPort = port;
|
|
}
|
|
isDevelopment() {
|
|
return this.state.isDev;
|
|
}
|
|
setDevelopment(isDev) {
|
|
this.state.isDev = isDev;
|
|
}
|
|
reset() {
|
|
this.state = {
|
|
mainWindow: null,
|
|
serverPort: 3001,
|
|
isDev: false
|
|
};
|
|
}
|
|
};
|
|
var electronState = new ElectronState();
|
|
|
|
// electron/main.ts
|
|
log2.initialize();
|
|
var __filename = fileURLToPath(import.meta.url);
|
|
var __dirname = path2.dirname(__filename);
|
|
process.env.NOTEBOOK_ROOT = path2.join(app.getPath("documents"), "XCDesktop");
|
|
if (!fs2.existsSync(process.env.NOTEBOOK_ROOT)) {
|
|
try {
|
|
fs2.mkdirSync(process.env.NOTEBOOK_ROOT, { recursive: true });
|
|
} catch (err) {
|
|
log2.error("Failed to create notebook directory:", err);
|
|
}
|
|
}
|
|
electronState.setDevelopment(!app.isPackaged);
|
|
var lastClipboardText = "";
|
|
function startClipboardWatcher() {
|
|
lastClipboardText = clipboard.readText();
|
|
setInterval(() => {
|
|
try {
|
|
const currentText = clipboard.readText();
|
|
if (currentText && currentText !== lastClipboardText) {
|
|
lastClipboardText = currentText;
|
|
log2.info("Clipboard changed, syncing to remote");
|
|
const win = electronState.getMainWindow();
|
|
if (win) {
|
|
win.webContents.send("remote-clipboard-auto-sync", currentText);
|
|
}
|
|
}
|
|
} catch (e) {
|
|
}
|
|
}, 1e3);
|
|
}
|
|
async function createWindow() {
|
|
const initialSymbolColor = nativeTheme.shouldUseDarkColors ? "#ffffff" : "#000000";
|
|
const mainWindow = new BrowserWindow3({
|
|
width: 1280,
|
|
height: 800,
|
|
minWidth: 1600,
|
|
minHeight: 900,
|
|
autoHideMenuBar: true,
|
|
titleBarStyle: "hidden",
|
|
titleBarOverlay: {
|
|
color: "#00000000",
|
|
symbolColor: initialSymbolColor,
|
|
height: 32
|
|
},
|
|
webPreferences: {
|
|
nodeIntegration: false,
|
|
contextIsolation: true,
|
|
sandbox: false,
|
|
webviewTag: true,
|
|
preload: path2.join(__dirname, "preload.cjs")
|
|
}
|
|
});
|
|
electronState.setMainWindow(mainWindow);
|
|
mainWindow.setMenu(null);
|
|
mainWindow.webContents.setWindowOpenHandler(({ url }) => {
|
|
if (url.startsWith("http:") || url.startsWith("https:")) {
|
|
shell.openExternal(url);
|
|
return { action: "deny" };
|
|
}
|
|
return { action: "allow" };
|
|
});
|
|
if (electronState.isDevelopment()) {
|
|
log2.info("Loading development URL...");
|
|
try {
|
|
await mainWindow.loadURL("http://localhost:5173");
|
|
} catch (e) {
|
|
log2.error("Failed to load dev URL. Make sure npm run electron:dev is used.", e);
|
|
}
|
|
mainWindow.webContents.openDevTools();
|
|
} else {
|
|
log2.info(`Loading production URL with port ${electronState.getServerPort()}...`);
|
|
await mainWindow.loadURL(`http://localhost:${electronState.getServerPort()}`);
|
|
}
|
|
}
|
|
ipcMain.handle("export-pdf", async (event, title, htmlContent) => {
|
|
const win = BrowserWindow3.fromWebContents(event.sender);
|
|
if (!win) return { success: false, error: "No window found" };
|
|
try {
|
|
const { filePath } = await dialog2.showSaveDialog(win, {
|
|
title: "\u5BFC\u51FA PDF",
|
|
defaultPath: `${title}.pdf`,
|
|
filters: [{ name: "PDF Files", extensions: ["pdf"] }]
|
|
});
|
|
if (!filePath) return { success: false, canceled: true };
|
|
if (!htmlContent) {
|
|
throw new Error("No HTML content provided for PDF export");
|
|
}
|
|
const pdfData = await generatePdf(htmlContent);
|
|
fs2.writeFileSync(filePath, pdfData);
|
|
return { success: true, filePath };
|
|
} catch (error) {
|
|
log2.error("Export PDF failed:", error);
|
|
return { success: false, error: error.message };
|
|
}
|
|
});
|
|
ipcMain.handle("select-html-file", async (event) => {
|
|
const win = BrowserWindow3.fromWebContents(event.sender);
|
|
return selectHtmlFile(win);
|
|
});
|
|
ipcMain.handle("update-titlebar-buttons", async (event, symbolColor) => {
|
|
const win = BrowserWindow3.fromWebContents(event.sender);
|
|
if (win) {
|
|
win.setTitleBarOverlay({ symbolColor });
|
|
return { success: true };
|
|
}
|
|
return { success: false };
|
|
});
|
|
ipcMain.handle("clipboard-read-text", async () => {
|
|
try {
|
|
const text = clipboard.readText();
|
|
return { success: true, text };
|
|
} catch (error) {
|
|
log2.error("Clipboard read failed:", error);
|
|
return { success: false, error: error.message };
|
|
}
|
|
});
|
|
ipcMain.handle("clipboard-write-text", async (event, text) => {
|
|
try {
|
|
clipboard.writeText(text);
|
|
return { success: true };
|
|
} catch (error) {
|
|
log2.error("Clipboard write failed:", error);
|
|
return { success: false, error: error.message };
|
|
}
|
|
});
|
|
ipcMain.handle("remote-fetch-drives", async (_event, serverHost, port, password) => {
|
|
try {
|
|
let url = `http://${serverHost}:${port}/api/files/drives`;
|
|
if (password) {
|
|
url += `?password=${encodeURIComponent(password)}`;
|
|
}
|
|
const response = await fetch(url);
|
|
if (!response.ok) {
|
|
throw new Error(`Failed to fetch drives: ${response.statusText}`);
|
|
}
|
|
const data = await response.json();
|
|
const items = data.items || [];
|
|
return {
|
|
success: true,
|
|
data: items.map((item) => ({
|
|
name: item.name,
|
|
path: item.name,
|
|
type: item.isDirectory ? "dir" : "file",
|
|
size: item.size,
|
|
modified: ""
|
|
}))
|
|
};
|
|
} catch (error) {
|
|
log2.error("Remote fetch drives failed:", error);
|
|
return { success: false, error: error.message };
|
|
}
|
|
});
|
|
ipcMain.handle("remote-fetch-files", async (_event, serverHost, port, filePath, password) => {
|
|
try {
|
|
let url = `http://${serverHost}:${port}/api/files/browse?path=${encodeURIComponent(filePath)}&allowSystem=true`;
|
|
if (password) {
|
|
url += `&password=${encodeURIComponent(password)}`;
|
|
}
|
|
const response = await fetch(url);
|
|
if (!response.ok) {
|
|
throw new Error(`Failed to fetch files: ${response.statusText}`);
|
|
}
|
|
const data = await response.json();
|
|
const items = data.items || [];
|
|
return {
|
|
success: true,
|
|
data: items.map((item) => ({
|
|
name: item.name,
|
|
path: data.currentPath ? `${data.currentPath}/${item.name}` : item.name,
|
|
type: item.isDirectory ? "dir" : "file",
|
|
size: item.size,
|
|
modified: item.modified?.toString()
|
|
}))
|
|
};
|
|
} catch (error) {
|
|
log2.error("Remote fetch files failed:", error);
|
|
return { success: false, error: error.message };
|
|
}
|
|
});
|
|
ipcMain.handle("remote-upload-file", async (_event, serverHost, port, filePath, remotePath, password) => {
|
|
try {
|
|
const win = electronState.getMainWindow();
|
|
if (!win) {
|
|
throw new Error("No window found");
|
|
}
|
|
const fullPath = path2.resolve(filePath);
|
|
if (!fs2.existsSync(fullPath)) {
|
|
throw new Error("File not found");
|
|
}
|
|
const fileBuffer = fs2.readFileSync(fullPath);
|
|
const fileName = path2.basename(fullPath);
|
|
let url = `http://${serverHost}:${port}/api/files/upload`;
|
|
if (password) {
|
|
url += `?password=${encodeURIComponent(password)}`;
|
|
}
|
|
const formData = new FormData();
|
|
const blob = new Blob([fileBuffer]);
|
|
formData.append("file", blob, fileName);
|
|
if (remotePath) {
|
|
formData.append("path", remotePath);
|
|
}
|
|
const response = await fetch(url, {
|
|
method: "POST",
|
|
body: formData
|
|
});
|
|
if (!response.ok) {
|
|
throw new Error(`Upload failed: ${response.statusText}`);
|
|
}
|
|
return { success: true };
|
|
} catch (error) {
|
|
log2.error("Remote upload failed:", error);
|
|
return { success: false, error: error.message };
|
|
}
|
|
});
|
|
ipcMain.handle("remote-download-file", async (_event, serverHost, port, fileName, remotePath, password) => {
|
|
try {
|
|
const win = electronState.getMainWindow();
|
|
if (!win) {
|
|
throw new Error("No window found");
|
|
}
|
|
let url = `http://${serverHost}:${port}/api/files/${encodeURIComponent(fileName)}`;
|
|
if (password) {
|
|
url += `?password=${encodeURIComponent(password)}`;
|
|
}
|
|
const response = await fetch(url);
|
|
if (!response.ok) {
|
|
throw new Error(`Download failed: ${response.statusText}`);
|
|
}
|
|
const buffer = await response.arrayBuffer();
|
|
const { filePath } = await dialog2.showSaveDialog(win, {
|
|
title: "\u4FDD\u5B58\u6587\u4EF6",
|
|
defaultPath: fileName
|
|
});
|
|
if (!filePath) {
|
|
return { success: false, canceled: true };
|
|
}
|
|
fs2.writeFileSync(filePath, Buffer.from(buffer));
|
|
return { success: true, filePath };
|
|
} catch (error) {
|
|
log2.error("Remote download failed:", error);
|
|
return { success: false, error: error.message };
|
|
}
|
|
});
|
|
async function startServer() {
|
|
if (electronState.isDevelopment()) {
|
|
log2.info("In dev mode, assuming external servers are running.");
|
|
return;
|
|
}
|
|
const serverPath = path2.join(__dirname, "../dist-api/server.js");
|
|
const serverUrl = pathToFileURL(serverPath).href;
|
|
log2.info(`Starting internal server from: ${serverPath}`);
|
|
try {
|
|
const serverModule = await import(serverUrl);
|
|
if (serverModule.startServer) {
|
|
const port = await serverModule.startServer();
|
|
electronState.setServerPort(port);
|
|
log2.info(`Internal server started successfully on port ${port}`);
|
|
} else {
|
|
log2.warn("startServer function not found in server module, using default port 3001");
|
|
}
|
|
} catch (e) {
|
|
log2.error("Failed to start internal server:", e);
|
|
}
|
|
}
|
|
app.whenReady().then(async () => {
|
|
await startServer();
|
|
await createWindow();
|
|
startClipboardWatcher();
|
|
globalShortcut.register("CommandOrControl+Shift+C", () => {
|
|
log2.info("Global shortcut: sync clipboard to remote");
|
|
const win = electronState.getMainWindow();
|
|
if (win) {
|
|
win.webContents.send("remote-clipboard-sync-to-remote");
|
|
}
|
|
});
|
|
globalShortcut.register("CommandOrControl+Shift+V", () => {
|
|
log2.info("Global shortcut: sync clipboard from remote");
|
|
const win = electronState.getMainWindow();
|
|
if (win) {
|
|
win.webContents.send("remote-clipboard-sync-from-remote");
|
|
}
|
|
});
|
|
app.on("activate", () => {
|
|
if (BrowserWindow3.getAllWindows().length === 0) {
|
|
createWindow();
|
|
}
|
|
});
|
|
});
|
|
app.on("window-all-closed", () => {
|
|
globalShortcut.unregisterAll();
|
|
if (process.platform !== "darwin") {
|
|
app.quit();
|
|
}
|
|
});
|
|
//# sourceMappingURL=main.js.map
|