// main.js (Main Process)
const { app, BrowserWindow, ipcMain } = require('electron');
const path = require('path');
 
function createWindow() {
  const win = new BrowserWindow({
    width: 1200,
    height: 800,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      contextIsolation: true,
      nodeIntegration: false,
    },
  });
 
  win.loadFile('index.html');
}
 
ipcMain.handle('read-file', async (event, filePath) => {
  const fs = require('fs').promises;
  return fs.readFile(filePath, 'utf-8');
});
 
app.whenReady().then(createWindow);

// preload.js (Bridge between main and renderer)
const { contextBridge, ipcRenderer } = require('electron');
 
contextBridge.exposeInMainWorld('electronAPI', {
  readFile: (filePath) => ipcRenderer.invoke('read-file', filePath),
  onSave: (callback) => ipcRenderer.on('save', callback),
});

// renderer.js (Frontend)
async function loadDocument(path) {
  const content = await window.electronAPI.readFile(path);
  document.getElementById('editor').value = content;
}

// src-tauri/src/main.rs
use tauri::Manager;
use serde::{Deserialize, Serialize};
 
#[derive(Serialize, Deserialize)]
struct Document {
    title: String,
    content: String,
    modified: bool,
}
 
#[tauri::command]
async fn read_file(path: String) -> Result<String, String> {
    tokio::fs::read_to_string(&path)
        .await
        .map_err(|e| e.to_string())
}
 
#[tauri::command]
async fn save_file(path: String, content: String) -> Result<(), String> {
    tokio::fs::write(&path, content)
        .await
        .map_err(|e| e.to_string())
}
 
#[tauri::command]
fn get_system_info() -> SystemInfo {
    SystemInfo {
        os: std::env::consts::OS.to_string(),
        arch: std::env::consts::ARCH.to_string(),
        hostname: hostname::get()
            .map(|h| h.to_string_lossy().to_string())
            .unwrap_or_default(),
    }
}
 
fn main() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![
            read_file,
            save_file,
            get_system_info,
        ])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

// Frontend (TypeScript)
import { invoke } from '@tauri-apps/api/core';
import { open, save } from '@tauri-apps/plugin-dialog';
import { readTextFile, writeTextFile } from '@tauri-apps/plugin-fs';
 
async function openDocument() {
  const filePath = await open({
    filters: [{ name: 'Text', extensions: ['txt', 'md'] }],
  });
  if (filePath) {
    const content = await readTextFile(filePath as string);
    editor.setValue(content);
  }
}
 
async function saveDocument() {
  const path = await save({
    filters: [{ name: 'Text', extensions: ['txt', 'md'] }],
  });
  if (path) {
    await writeTextFile(path, editor.getValue());
  }
}
 
// Invoke custom Rust commands with type safety
const info = await invoke<SystemInfo>('get_system_info');
console.log(`Running on ${info.os} (${info.arch})`);

// Tauri's tauri.conf.json - Capability-based security
{
  "app": {
    "security": {
      "csp": "default-src 'self'; script-src 'self'",
      "capabilities": [
        {
          "identifier": "main-capability",
          "windows": ["main"],
          "permissions": [
            "core:default",
            "dialog:default",
            "fs:allow-read",
            "fs:allow-write-text-file",
            "shell:default"
          ]
        }
      ]
    }
  }
}

# Create project
mkdir electron-app && cd electron-app
npm init -y
npm install electron --save-dev

// package.json
{
  "name": "my-electron-app",
  "version": "1.0.0",
  "main": "main.js",
  "scripts": {
    "start": "electron .",
    "build": "electron-builder",
    "build:mac": "electron-builder --mac",
    "build:win": "electron-builder --win",
    "build:linux": "electron-builder --linux"
  },
  "build": {
    "appId": "com.example.myapp",
    "productName": "My App",
    "mac": { "target": "dmg" },
    "win": { "target": "nsis" },
    "linux": { "target": "AppImage" }
  },
  "devDependencies": {
    "electron": "^28.0.0",
    "electron-builder": "^24.0.0"
  }
}

# Prerequisites: Rust toolchain
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
 
# Create project with any frontend framework
npm create tauri-app@latest my-tauri-app
cd my-tauri-app
 
# Development
npm run tauri dev
 
# Production build
npm run tauri build

# src-tauri/Cargo.toml
[package]
name = "my-tauri-app"
version = "0.1.0"
edition = "2021"
 
[dependencies]
tauri = { version = "2", features = [] }
tauri-plugin-dialog = "2"
tauri-plugin-fs = "2"
tauri-plugin-shell = "2"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tokio = { version = "1", features = ["full"] }
 
[build-dependencies]
tauri-build = { version = "2", features = [] }

// src-tauri/tauri.conf.json
{
  "$schema": "https://raw.githubusercontent.com/nickel-org/nickel.rs/main/examples/example_assets/schema.json",
  "productName": "My Tauri App",
  "version": "0.1.0",
  "identifier": "com.example.myapp",
  "build": {
    "frontendDist": "../dist",
    "devUrl": "http://localhost:5173",
    "beforeDevCommand": "npm run dev",
    "beforeBuildCommand": "npm run build"
  },
  "app": {
    "windows": [
      {
        "title": "My Tauri App",
        "width": 1200,
        "height": 800,
        "resizable": true,
        "fullscreen": false
      }
    ],
    "security": {
      "csp": "default-src 'self'; script-src 'self' 'unsafe-inline'"
    }
  }
}

# .github/workflows/release.yml (Tauri)
name: Release
on:
  push:
    tags: ['v*']
 
jobs:
  release:
    strategy:
      matrix:
        include:
          - platform: macos-latest
            target: aarch64-apple-darwin
          - platform: macos-latest
            target: x86_64-apple-darwin
          - platform: ubuntu-22.04
            target: x86_64-unknown-linux-gnu
          - platform: windows-latest
            target: x86_64-pc-windows-msvc
 
    runs-on: ${{ matrix.platform }}
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
        with:
          targets: ${{ matrix.target }}
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npm ci
      - uses: tauri-apps/tauri-action@v0
        with:
          target: ${{ matrix.target }}

// Use BrowserWindow with optimized settings
const win = new BrowserWindow({
  webPreferences: {
    offscreen: false,
    contextIsolation: true,
    nodeIntegration: false,
    // Reduce renderer memory usage
    v8CacheOptions: 'code',
    spellcheck: false,
  },
});
 
// Lazy-load heavy modules
let heavyModule;
async function getHeavyModule() {
  if (!heavyModule) {
    heavyModule = await import('./heavy-module.js');
  }
  return heavyModule;
}
 
// Use web workers for CPU-intensive tasks
const worker = new Worker('compute.js');
worker.postMessage({ data: largeDataset });
worker.onmessage = (e) => updateUI(e.data);

// Use async commands to avoid blocking the UI thread
#[tauri::command]
async fn process_large_file(path: String) -> Result<ProcessResult, String> {
    let content = tokio::fs::read_to_string(&path)
        .await
        .map_err(|e| e.to_string())?;
 
    // Process in a background thread
    let result = tokio::task::spawn_blocking(move || {
        expensive_computation(&content)
    })
    .await
    .map_err(|e| e.to_string())?;
 
    Ok(result)
}
 
// Use state management for shared resources
use tauri::State;
use std::sync::Mutex;
 
struct AppState {
    db: Mutex<Database>,
}
 
#[tauri::command]
fn query_data(state: State<AppState>, query: String) -> Result<Vec<Row>, String> {
    let db = state.db.lock().map_err(|e| e.to_string())?;
    db.execute(&query).map_err(|e| e.to_string())
}

// shared-worker.js
const state = { documents: new Map() };
 
self.onconnect = (e) => {
  const port = e.ports[0];
  port.onmessage = (event) => {
    const { type, payload } = event.data;
    switch (type) {
      case 'GET_STATE':
        port.postMessage({ type: 'STATE', payload: Object.fromEntries(state.documents) });
        break;
      case 'UPDATE_DOC':
        state.documents.set(payload.id, payload);
        broadcastToAll({ type: 'DOC_UPDATED', payload });
        break;
    }
  };
};

// Custom Tauri plugin for database access
use tauri::plugin::{Builder, TauriPlugin};
use tauri::Runtime;
 
pub fn init<R: Runtime>() -> TauriPlugin<R> {
    Builder::new("database")
        .invoke_handler(tauri::generate_handler![
            db_query,
            db_execute,
            db_migrate,
        ])
        .setup(|app, _api| {
            let db_path = app.path().app_data_dir().unwrap().join("app.db");
            let conn = Connection::open(db_path)?;
            // Run migrations
            conn.execute_batch(include_str!("migrations.sql"))?;
            app.manage(Mutex::new(conn));
            Ok(())
        })
        .build()
}

// test/app.spec.js
const { _electron: electron } = require('playwright');
 
describe('Electron App', () => {
  let electronApp;
 
  beforeAll(async () => {
    electronApp = await electron.launch({ args: ['main.js'] });
  });
 
  afterAll(async () => {
    await electronApp.close();
  });
 
  it('should create a window', async () => {
    const window = await electronApp.firstWindow();
    const title = await window.title();
    expect(title).toBe('My App');
  });
 
  it('should handle IPC communication', async () => {
    const window = await electronApp.firstWindow();
    const result = await window.evaluate(() => window.electronAPI.readFile('/etc/hostname'));
    expect(result).toBeTruthy();
  });
});

// src-tauri/tests/commands.rs
#[cfg(test)]
mod tests {
    use super::*;
 
    #[test]
    fn test_get_system_info() {
        let info = get_system_info();
        assert!(!info.os.is_empty());
        assert!(!info.arch.is_empty());
    }
 
    #[tokio::test]
    async fn test_read_file() {
        let result = read_file("/etc/hostname".to_string()).await;
        assert!(result.is_ok());
    }
 
    #[tokio::test]
    async fn test_read_nonexistent_file() {
        let result = read_file("/nonexistent/path".to_string()).await;
        assert!(result.is_err());
    }
}