Browse Source
- Implement XDG Base Directory Specification for data storage - Use $XDG_DATA_HOME (defaults to ~/.local/share) for data files - Add proper directory permissions (700) for security - Fallback to ~/.timesafari if XDG paths fail - Add graceful degradation for SQLite failures - Allow app to boot even if SQLite initialization fails - Track and expose initialization errors via IPC - Add availability checks to all SQLite operations - Improve error reporting and logging - Security improvements - Set secure permissions (700) on data directories - Verify directory permissions on existing paths - Add proper error handling for permission issues TODO: - Fix database creation - Add retry logic for initialization - Add reinitialization capability - Add more detailed error reporting - Consider fallback storage optionspull/134/head
Matthew Raymer
1 week ago
20 changed files with 6498 additions and 30 deletions
@ -0,0 +1,55 @@ |
|||||
|
# NPM renames .gitignore to .npmignore |
||||
|
# In order to prevent that, we remove the initial "." |
||||
|
# And the CLI then renames it |
||||
|
app |
||||
|
node_modules |
||||
|
build |
||||
|
dist |
||||
|
logs |
||||
|
# Node.js dependencies |
||||
|
node_modules/ |
||||
|
npm-debug.log* |
||||
|
yarn-debug.log* |
||||
|
yarn-error.log* |
||||
|
.pnpm-debug.log* |
||||
|
|
||||
|
# Capacitor build outputs |
||||
|
web/ |
||||
|
ios/ |
||||
|
android/ |
||||
|
electron/app/ |
||||
|
|
||||
|
# Capacitor SQLite plugin data (important!) |
||||
|
capacitor-sqlite/ |
||||
|
|
||||
|
# TypeScript / build output |
||||
|
dist/ |
||||
|
build/ |
||||
|
*.log |
||||
|
|
||||
|
# Development / IDE files |
||||
|
.env.local |
||||
|
.env.development.local |
||||
|
.env.test.local |
||||
|
.env.production.local |
||||
|
|
||||
|
# VS Code |
||||
|
.vscode/ |
||||
|
!.vscode/extensions.json |
||||
|
|
||||
|
# JetBrains IDEs (IntelliJ, WebStorm, etc.) |
||||
|
.idea/ |
||||
|
*.iml |
||||
|
*.iws |
||||
|
|
||||
|
# macOS specific |
||||
|
.DS_Store |
||||
|
*.swp |
||||
|
*~ |
||||
|
*.tmp |
||||
|
|
||||
|
# Windows specific |
||||
|
Thumbs.db |
||||
|
ehthumbs.db |
||||
|
Desktop.ini |
||||
|
$RECYCLE.BIN/ |
||||
|
After Width: | Height: | Size: 142 KiB |
|
After Width: | Height: | Size: 121 KiB |
|
After Width: | Height: | Size: 159 KiB |
|
After Width: | Height: | Size: 12 KiB |
@ -0,0 +1,63 @@ |
|||||
|
{ |
||||
|
"appId": "com.timesafari.app", |
||||
|
"appName": "TimeSafari", |
||||
|
"webDir": "dist", |
||||
|
"bundledWebRuntime": false, |
||||
|
"server": { |
||||
|
"cleartext": true, |
||||
|
"androidScheme": "https" |
||||
|
}, |
||||
|
"plugins": { |
||||
|
"App": { |
||||
|
"appUrlOpen": { |
||||
|
"handlers": [ |
||||
|
{ |
||||
|
"url": "timesafari://*", |
||||
|
"autoVerify": true |
||||
|
} |
||||
|
] |
||||
|
} |
||||
|
}, |
||||
|
"SQLite": { |
||||
|
"iosDatabaseLocation": "Library/CapacitorDatabase", |
||||
|
"iosIsEncryption": true, |
||||
|
"iosBiometric": { |
||||
|
"biometricAuth": true, |
||||
|
"biometricTitle": "Biometric login for TimeSafari" |
||||
|
}, |
||||
|
"androidIsEncryption": true, |
||||
|
"androidBiometric": { |
||||
|
"biometricAuth": true, |
||||
|
"biometricTitle": "Biometric login for TimeSafari" |
||||
|
} |
||||
|
}, |
||||
|
"CapacitorSQLite": { |
||||
|
"electronIsEncryption": false, |
||||
|
"electronMacLocation": "~/Library/Application Support/TimeSafari", |
||||
|
"electronWindowsLocation": "C:\\ProgramData\\TimeSafari", |
||||
|
"electronLinuxLocation": "~/.local/share/TimeSafari" |
||||
|
} |
||||
|
}, |
||||
|
"ios": { |
||||
|
"contentInset": "always", |
||||
|
"allowsLinkPreview": true, |
||||
|
"scrollEnabled": true, |
||||
|
"limitsNavigationsToAppBoundDomains": true, |
||||
|
"backgroundColor": "#ffffff", |
||||
|
"allowNavigation": [ |
||||
|
"*.timesafari.app", |
||||
|
"*.jsdelivr.net", |
||||
|
"api.endorser.ch" |
||||
|
] |
||||
|
}, |
||||
|
"android": { |
||||
|
"allowMixedContent": false, |
||||
|
"captureInput": true, |
||||
|
"webContentsDebuggingEnabled": false, |
||||
|
"allowNavigation": [ |
||||
|
"*.timesafari.app", |
||||
|
"*.jsdelivr.net", |
||||
|
"api.endorser.ch" |
||||
|
] |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,28 @@ |
|||||
|
{ |
||||
|
"appId": "com.yourdoamnin.yourapp", |
||||
|
"directories": { |
||||
|
"buildResources": "resources" |
||||
|
}, |
||||
|
"files": [ |
||||
|
"assets/**/*", |
||||
|
"build/**/*", |
||||
|
"capacitor.config.*", |
||||
|
"app/**/*" |
||||
|
], |
||||
|
"publish": { |
||||
|
"provider": "github" |
||||
|
}, |
||||
|
"nsis": { |
||||
|
"allowElevation": true, |
||||
|
"oneClick": false, |
||||
|
"allowToChangeInstallationDirectory": true |
||||
|
}, |
||||
|
"win": { |
||||
|
"target": "nsis", |
||||
|
"icon": "assets/appIcon.ico" |
||||
|
}, |
||||
|
"mac": { |
||||
|
"category": "your.app.category.type", |
||||
|
"target": "dmg" |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,75 @@ |
|||||
|
/* eslint-disable no-undef */ |
||||
|
/* eslint-disable @typescript-eslint/no-var-requires */ |
||||
|
const cp = require('child_process'); |
||||
|
const chokidar = require('chokidar'); |
||||
|
const electron = require('electron'); |
||||
|
|
||||
|
let child = null; |
||||
|
const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm'; |
||||
|
const reloadWatcher = { |
||||
|
debouncer: null, |
||||
|
ready: false, |
||||
|
watcher: null, |
||||
|
restarting: false, |
||||
|
}; |
||||
|
|
||||
|
///*
|
||||
|
function runBuild() { |
||||
|
return new Promise((resolve, _reject) => { |
||||
|
let tempChild = cp.spawn(npmCmd, ['run', 'build']); |
||||
|
tempChild.once('exit', () => { |
||||
|
resolve(); |
||||
|
}); |
||||
|
tempChild.stdout.pipe(process.stdout); |
||||
|
}); |
||||
|
} |
||||
|
//*/
|
||||
|
|
||||
|
async function spawnElectron() { |
||||
|
if (child !== null) { |
||||
|
child.stdin.pause(); |
||||
|
child.kill(); |
||||
|
child = null; |
||||
|
await runBuild(); |
||||
|
} |
||||
|
child = cp.spawn(electron, ['--inspect=5858', './']); |
||||
|
child.on('exit', () => { |
||||
|
if (!reloadWatcher.restarting) { |
||||
|
process.exit(0); |
||||
|
} |
||||
|
}); |
||||
|
child.stdout.pipe(process.stdout); |
||||
|
} |
||||
|
|
||||
|
function setupReloadWatcher() { |
||||
|
reloadWatcher.watcher = chokidar |
||||
|
.watch('./src/**/*', { |
||||
|
ignored: /[/\\]\./, |
||||
|
persistent: true, |
||||
|
}) |
||||
|
.on('ready', () => { |
||||
|
reloadWatcher.ready = true; |
||||
|
}) |
||||
|
.on('all', (_event, _path) => { |
||||
|
if (reloadWatcher.ready) { |
||||
|
clearTimeout(reloadWatcher.debouncer); |
||||
|
reloadWatcher.debouncer = setTimeout(async () => { |
||||
|
console.log('Restarting'); |
||||
|
reloadWatcher.restarting = true; |
||||
|
await spawnElectron(); |
||||
|
reloadWatcher.restarting = false; |
||||
|
reloadWatcher.ready = false; |
||||
|
clearTimeout(reloadWatcher.debouncer); |
||||
|
reloadWatcher.debouncer = null; |
||||
|
reloadWatcher.watcher = null; |
||||
|
setupReloadWatcher(); |
||||
|
}, 500); |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
(async () => { |
||||
|
await runBuild(); |
||||
|
await spawnElectron(); |
||||
|
setupReloadWatcher(); |
||||
|
})(); |
||||
File diff suppressed because it is too large
@ -0,0 +1,51 @@ |
|||||
|
{ |
||||
|
"name": "TimeSafari", |
||||
|
"version": "1.0.0", |
||||
|
"description": "TimeSafari Electron App", |
||||
|
"author": { |
||||
|
"name": "", |
||||
|
"email": "" |
||||
|
}, |
||||
|
"repository": { |
||||
|
"type": "git", |
||||
|
"url": "" |
||||
|
}, |
||||
|
"license": "MIT", |
||||
|
"main": "build/src/index.js", |
||||
|
"scripts": { |
||||
|
"build": "tsc && electron-rebuild", |
||||
|
"electron:start-live": "node ./live-runner.js", |
||||
|
"electron:start": "npm run build && electron --inspect=5858 ./", |
||||
|
"electron:pack": "npm run build && electron-builder build --dir -c ./electron-builder.config.json", |
||||
|
"electron:make": "npm run build && electron-builder build -c ./electron-builder.config.json -p always" |
||||
|
}, |
||||
|
"dependencies": { |
||||
|
"@capacitor-community/electron": "^5.0.0", |
||||
|
"@capacitor-community/sqlite": "^6.0.2", |
||||
|
"better-sqlite3-multiple-ciphers": "^11.10.0", |
||||
|
"chokidar": "~3.5.3", |
||||
|
"crypto": "^1.0.1", |
||||
|
"crypto-js": "^4.2.0", |
||||
|
"electron-is-dev": "~2.0.0", |
||||
|
"electron-json-storage": "^4.6.0", |
||||
|
"electron-serve": "~1.1.0", |
||||
|
"electron-unhandled": "~4.0.1", |
||||
|
"electron-updater": "^5.3.0", |
||||
|
"electron-window-state": "^5.0.3", |
||||
|
"jszip": "^3.10.1", |
||||
|
"node-fetch": "^2.6.7" |
||||
|
}, |
||||
|
"devDependencies": { |
||||
|
"@types/better-sqlite3": "^7.6.13", |
||||
|
"@types/crypto-js": "^4.2.2", |
||||
|
"@types/electron-json-storage": "^4.5.4", |
||||
|
"electron": "^26.2.2", |
||||
|
"electron-builder": "~23.6.0", |
||||
|
"source-map-support": "^0.5.21", |
||||
|
"typescript": "^5.0.4" |
||||
|
}, |
||||
|
"keywords": [ |
||||
|
"capacitor", |
||||
|
"electron" |
||||
|
] |
||||
|
} |
||||
@ -0,0 +1,10 @@ |
|||||
|
/* eslint-disable no-undef */ |
||||
|
/* eslint-disable @typescript-eslint/no-var-requires */ |
||||
|
const electronPublish = require('electron-publish'); |
||||
|
|
||||
|
class Publisher extends electronPublish.Publisher { |
||||
|
async upload(task) { |
||||
|
console.log('electron-publisher-custom', task.file); |
||||
|
} |
||||
|
} |
||||
|
module.exports = Publisher; |
||||
@ -0,0 +1,110 @@ |
|||||
|
import type { CapacitorElectronConfig } from '@capacitor-community/electron'; |
||||
|
import { getCapacitorElectronConfig, setupElectronDeepLinking } from '@capacitor-community/electron'; |
||||
|
import type { MenuItemConstructorOptions } from 'electron'; |
||||
|
import { app, MenuItem } from 'electron'; |
||||
|
import electronIsDev from 'electron-is-dev'; |
||||
|
import unhandled from 'electron-unhandled'; |
||||
|
import { autoUpdater } from 'electron-updater'; |
||||
|
|
||||
|
import { ElectronCapacitorApp, setupContentSecurityPolicy, setupReloadWatcher } from './setup'; |
||||
|
import { initializeSQLite, setupSQLiteHandlers } from './rt/sqlite-init'; |
||||
|
|
||||
|
// Graceful handling of unhandled errors.
|
||||
|
unhandled(); |
||||
|
|
||||
|
// Define our menu templates (these are optional)
|
||||
|
const trayMenuTemplate: (MenuItemConstructorOptions | MenuItem)[] = [new MenuItem({ label: 'Quit App', role: 'quit' })]; |
||||
|
const appMenuBarMenuTemplate: (MenuItemConstructorOptions | MenuItem)[] = [ |
||||
|
{ role: process.platform === 'darwin' ? 'appMenu' : 'fileMenu' }, |
||||
|
{ role: 'viewMenu' }, |
||||
|
]; |
||||
|
|
||||
|
// Get Config options from capacitor.config
|
||||
|
const capacitorFileConfig: CapacitorElectronConfig = getCapacitorElectronConfig(); |
||||
|
|
||||
|
// Initialize our app. You can pass menu templates into the app here.
|
||||
|
const myCapacitorApp = new ElectronCapacitorApp(capacitorFileConfig, trayMenuTemplate, appMenuBarMenuTemplate); |
||||
|
|
||||
|
// If deeplinking is enabled then we will set it up here.
|
||||
|
if (capacitorFileConfig.electron?.deepLinkingEnabled) { |
||||
|
setupElectronDeepLinking(myCapacitorApp, { |
||||
|
customProtocol: capacitorFileConfig.electron.deepLinkingCustomProtocol ?? 'mycapacitorapp', |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
// If we are in Dev mode, use the file watcher components.
|
||||
|
if (electronIsDev) { |
||||
|
setupReloadWatcher(myCapacitorApp); |
||||
|
} |
||||
|
|
||||
|
// Run Application
|
||||
|
(async () => { |
||||
|
try { |
||||
|
// Wait for electron app to be ready.
|
||||
|
await app.whenReady(); |
||||
|
|
||||
|
// Security - Set Content-Security-Policy based on whether or not we are in dev mode.
|
||||
|
setupContentSecurityPolicy(myCapacitorApp.getCustomURLScheme()); |
||||
|
|
||||
|
// Initialize SQLite and register handlers BEFORE app initialization
|
||||
|
console.log('[Main] Starting SQLite initialization...'); |
||||
|
try { |
||||
|
// Register handlers first to prevent "no handler" errors
|
||||
|
setupSQLiteHandlers(); |
||||
|
console.log('[Main] SQLite handlers registered'); |
||||
|
|
||||
|
// Then initialize the plugin
|
||||
|
await initializeSQLite(); |
||||
|
console.log('[Main] SQLite plugin initialized successfully'); |
||||
|
} catch (error) { |
||||
|
console.error('[Main] Failed to initialize SQLite:', error); |
||||
|
// Don't proceed with app initialization if SQLite fails
|
||||
|
throw new Error(`SQLite initialization failed: ${error instanceof Error ? error.message : 'Unknown error'}`); |
||||
|
} |
||||
|
|
||||
|
// Initialize our app, build windows, and load content.
|
||||
|
console.log('[Main] Starting app initialization...'); |
||||
|
await myCapacitorApp.init(); |
||||
|
console.log('[Main] App initialization complete'); |
||||
|
|
||||
|
// Check for updates if we are in a packaged app.
|
||||
|
if (!electronIsDev) { |
||||
|
console.log('[Main] Checking for updates...'); |
||||
|
autoUpdater.checkForUpdatesAndNotify(); |
||||
|
} |
||||
|
} catch (error) { |
||||
|
console.error('[Main] Fatal error during app initialization:', error); |
||||
|
// Ensure we notify the user before quitting
|
||||
|
const mainWindow = myCapacitorApp.getMainWindow(); |
||||
|
if (mainWindow && !mainWindow.isDestroyed()) { |
||||
|
mainWindow.webContents.send('app-error', { |
||||
|
type: 'initialization', |
||||
|
error: error instanceof Error ? error.message : 'Unknown error' |
||||
|
}); |
||||
|
// Give the window time to show the error
|
||||
|
setTimeout(() => app.quit(), 5000); |
||||
|
} else { |
||||
|
app.quit(); |
||||
|
} |
||||
|
} |
||||
|
})(); |
||||
|
|
||||
|
// Handle when all of our windows are close (platforms have their own expectations).
|
||||
|
app.on('window-all-closed', function () { |
||||
|
// On OS X it is common for applications and their menu bar
|
||||
|
// to stay active until the user quits explicitly with Cmd + Q
|
||||
|
if (process.platform !== 'darwin') { |
||||
|
app.quit(); |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
// When the dock icon is clicked.
|
||||
|
app.on('activate', async function () { |
||||
|
// On OS X it's common to re-create a window in the app when the
|
||||
|
// dock icon is clicked and there are no other windows open.
|
||||
|
if (myCapacitorApp.getMainWindow().isDestroyed()) { |
||||
|
await myCapacitorApp.init(); |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
// Place all ipc or other electron api calls and custom functionality under this line
|
||||
@ -0,0 +1,76 @@ |
|||||
|
/** |
||||
|
* Preload script for Electron |
||||
|
* Sets up context bridge and handles security policies |
||||
|
* @author Matthew Raymer |
||||
|
*/ |
||||
|
|
||||
|
import { contextBridge, ipcRenderer } from 'electron'; |
||||
|
|
||||
|
// Enable source maps in development
|
||||
|
if (process.env.NODE_ENV === 'development') { |
||||
|
require('source-map-support').install(); |
||||
|
} |
||||
|
|
||||
|
// Log that preload is running
|
||||
|
console.log('[Preload] Script starting...'); |
||||
|
|
||||
|
// Create a proxy for the CapacitorSQLite plugin
|
||||
|
const createSQLiteProxy = () => { |
||||
|
const MAX_RETRIES = 5; |
||||
|
const RETRY_DELAY = 1000; // 1 second
|
||||
|
|
||||
|
const withRetry = async (operation: string, ...args: any[]) => { |
||||
|
let lastError; |
||||
|
for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) { |
||||
|
try { |
||||
|
return await ipcRenderer.invoke(`sqlite-${operation}`, ...args); |
||||
|
} catch (error) { |
||||
|
lastError = error; |
||||
|
console.warn(`[Preload] SQLite operation ${operation} failed (attempt ${attempt}/${MAX_RETRIES}), retrying...`, error); |
||||
|
if (attempt < MAX_RETRIES) { |
||||
|
await new Promise(resolve => setTimeout(resolve, RETRY_DELAY)); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
throw new Error(`SQLite operation ${operation} failed after ${MAX_RETRIES} attempts: ${lastError?.message || 'Unknown error'}`); |
||||
|
}; |
||||
|
|
||||
|
return { |
||||
|
echo: (value: string) => withRetry('echo', value), |
||||
|
createConnection: (options: any) => withRetry('create-connection', options), |
||||
|
closeConnection: (options: any) => withRetry('close-connection', options), |
||||
|
execute: (options: any) => withRetry('execute', options), |
||||
|
query: (options: any) => withRetry('query', options), |
||||
|
isAvailable: () => withRetry('is-available'), |
||||
|
getPlatform: () => Promise.resolve('electron') |
||||
|
}; |
||||
|
}; |
||||
|
|
||||
|
// Set up context bridge for secure IPC communication
|
||||
|
contextBridge.exposeInMainWorld('electronAPI', { |
||||
|
// SQLite operations
|
||||
|
sqlite: createSQLiteProxy(), |
||||
|
|
||||
|
// Database status events
|
||||
|
onDatabaseStatus: (callback: (status: { status: string; error?: string }) => void) => { |
||||
|
ipcRenderer.on('database-status', (_event, status) => callback(status)); |
||||
|
return () => { |
||||
|
ipcRenderer.removeAllListeners('database-status'); |
||||
|
}; |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
// Expose CapacitorSQLite globally for the plugin system
|
||||
|
contextBridge.exposeInMainWorld('CapacitorSQLite', createSQLiteProxy()); |
||||
|
|
||||
|
// Handle uncaught errors
|
||||
|
window.addEventListener('unhandledrejection', (event) => { |
||||
|
console.error('[Preload] Unhandled promise rejection:', event.reason); |
||||
|
}); |
||||
|
|
||||
|
window.addEventListener('error', (event) => { |
||||
|
console.error('[Preload] Unhandled error:', event.error); |
||||
|
}); |
||||
|
|
||||
|
// Log that preload is complete
|
||||
|
console.log('[Preload] Script complete'); |
||||
@ -0,0 +1,6 @@ |
|||||
|
/* eslint-disable @typescript-eslint/no-var-requires */ |
||||
|
const CapacitorCommunitySqlite = require('../../../node_modules/@capacitor-community/sqlite/electron/dist/plugin.js'); |
||||
|
|
||||
|
module.exports = { |
||||
|
CapacitorCommunitySqlite, |
||||
|
} |
||||
@ -0,0 +1,88 @@ |
|||||
|
import { randomBytes } from 'crypto'; |
||||
|
import { ipcRenderer, contextBridge } from 'electron'; |
||||
|
import { EventEmitter } from 'events'; |
||||
|
|
||||
|
////////////////////////////////////////////////////////
|
||||
|
// eslint-disable-next-line @typescript-eslint/no-var-requires
|
||||
|
const plugins = require('./electron-plugins'); |
||||
|
|
||||
|
const randomId = (length = 5) => randomBytes(length).toString('hex'); |
||||
|
|
||||
|
const contextApi: { |
||||
|
[plugin: string]: { [functionName: string]: () => Promise<any> }; |
||||
|
} = {}; |
||||
|
|
||||
|
Object.keys(plugins).forEach((pluginKey) => { |
||||
|
Object.keys(plugins[pluginKey]) |
||||
|
.filter((className) => className !== 'default') |
||||
|
.forEach((classKey) => { |
||||
|
const functionList = Object.getOwnPropertyNames(plugins[pluginKey][classKey].prototype).filter( |
||||
|
(v) => v !== 'constructor' |
||||
|
); |
||||
|
|
||||
|
if (!contextApi[classKey]) { |
||||
|
contextApi[classKey] = {}; |
||||
|
} |
||||
|
|
||||
|
functionList.forEach((functionName) => { |
||||
|
if (!contextApi[classKey][functionName]) { |
||||
|
contextApi[classKey][functionName] = (...args) => ipcRenderer.invoke(`${classKey}-${functionName}`, ...args); |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
// Events
|
||||
|
if (plugins[pluginKey][classKey].prototype instanceof EventEmitter) { |
||||
|
const listeners: { [key: string]: { type: string; listener: (...args: any[]) => void } } = {}; |
||||
|
const listenersOfTypeExist = (type) => |
||||
|
!!Object.values(listeners).find((listenerObj) => listenerObj.type === type); |
||||
|
|
||||
|
Object.assign(contextApi[classKey], { |
||||
|
addListener(type: string, callback: (...args) => void) { |
||||
|
const id = randomId(); |
||||
|
|
||||
|
// Deduplicate events
|
||||
|
if (!listenersOfTypeExist(type)) { |
||||
|
ipcRenderer.send(`event-add-${classKey}`, type); |
||||
|
} |
||||
|
|
||||
|
const eventHandler = (_, ...args) => callback(...args); |
||||
|
|
||||
|
ipcRenderer.addListener(`event-${classKey}-${type}`, eventHandler); |
||||
|
listeners[id] = { type, listener: eventHandler }; |
||||
|
|
||||
|
return id; |
||||
|
}, |
||||
|
removeListener(id: string) { |
||||
|
if (!listeners[id]) { |
||||
|
throw new Error('Invalid id'); |
||||
|
} |
||||
|
|
||||
|
const { type, listener } = listeners[id]; |
||||
|
|
||||
|
ipcRenderer.removeListener(`event-${classKey}-${type}`, listener); |
||||
|
|
||||
|
delete listeners[id]; |
||||
|
|
||||
|
if (!listenersOfTypeExist(type)) { |
||||
|
ipcRenderer.send(`event-remove-${classKey}-${type}`); |
||||
|
} |
||||
|
}, |
||||
|
removeAllListeners(type: string) { |
||||
|
Object.entries(listeners).forEach(([id, listenerObj]) => { |
||||
|
if (!type || listenerObj.type === type) { |
||||
|
ipcRenderer.removeListener(`event-${classKey}-${listenerObj.type}`, listenerObj.listener); |
||||
|
ipcRenderer.send(`event-remove-${classKey}-${listenerObj.type}`); |
||||
|
delete listeners[id]; |
||||
|
} |
||||
|
}); |
||||
|
}, |
||||
|
}); |
||||
|
} |
||||
|
}); |
||||
|
}); |
||||
|
|
||||
|
contextBridge.exposeInMainWorld('CapacitorCustomPlatform', { |
||||
|
name: 'electron', |
||||
|
plugins: contextApi, |
||||
|
}); |
||||
|
////////////////////////////////////////////////////////
|
||||
@ -0,0 +1,356 @@ |
|||||
|
/** |
||||
|
* SQLite initialization for Capacitor Electron |
||||
|
* Handles database path setup, plugin initialization, and IPC handlers |
||||
|
* |
||||
|
* Database Path Handling: |
||||
|
* - Uses XDG Base Directory Specification for data storage |
||||
|
* - Uses modern plugin conventions (Capacitor 6+ / Plugin 6.x+) |
||||
|
* - Supports custom database names without enforced extensions |
||||
|
* - Maintains backward compatibility with legacy paths |
||||
|
* |
||||
|
* XDG Base Directory Specification: |
||||
|
* - Uses $XDG_DATA_HOME (defaults to ~/.local/share) for data files |
||||
|
* - Falls back to legacy path if XDG environment variables are not set |
||||
|
* |
||||
|
* @author Matthew Raymer |
||||
|
*/ |
||||
|
|
||||
|
import { app, ipcMain } from 'electron'; |
||||
|
import { CapacitorSQLite } from '@capacitor-community/sqlite/electron/dist/plugin.js'; |
||||
|
import fs from 'fs'; |
||||
|
import path from 'path'; |
||||
|
import os from 'os'; |
||||
|
|
||||
|
// Simple logger implementation with structured logging
|
||||
|
const logger = { |
||||
|
log: (...args: unknown[]) => console.log('[SQLite]', ...args), |
||||
|
error: (...args: unknown[]) => console.error('[SQLite]', ...args), |
||||
|
info: (...args: unknown[]) => console.info('[SQLite]', ...args), |
||||
|
warn: (...args: unknown[]) => console.warn('[SQLite]', ...args), |
||||
|
debug: (...args: unknown[]) => console.debug('[SQLite]', ...args), |
||||
|
}; |
||||
|
|
||||
|
// Database path resolution utilities following XDG Base Directory Specification
|
||||
|
const getAppDataPath = async (): Promise<string> => { |
||||
|
try { |
||||
|
// Get XDG_DATA_HOME or fallback to default
|
||||
|
const xdgDataHome = process.env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share'); |
||||
|
logger.info('XDG_DATA_HOME:', xdgDataHome); |
||||
|
|
||||
|
// Create app data directory following XDG spec
|
||||
|
const appDataDir = path.join(xdgDataHome, 'timesafari'); |
||||
|
logger.info('App data directory:', appDataDir); |
||||
|
|
||||
|
// Ensure directory exists with proper permissions (700)
|
||||
|
if (!fs.existsSync(appDataDir)) { |
||||
|
await fs.promises.mkdir(appDataDir, { |
||||
|
recursive: true, |
||||
|
mode: 0o700 // rwx------ for security
|
||||
|
}); |
||||
|
} else { |
||||
|
// Ensure existing directory has correct permissions
|
||||
|
await fs.promises.chmod(appDataDir, 0o700); |
||||
|
} |
||||
|
|
||||
|
return appDataDir; |
||||
|
} catch (error) { |
||||
|
logger.error('Error getting app data path:', error); |
||||
|
// Fallback to legacy path in user's home
|
||||
|
const fallbackDir = path.join(os.homedir(), '.timesafari'); |
||||
|
logger.warn('Using fallback app data directory:', fallbackDir); |
||||
|
|
||||
|
try { |
||||
|
if (!fs.existsSync(fallbackDir)) { |
||||
|
await fs.promises.mkdir(fallbackDir, { |
||||
|
recursive: true, |
||||
|
mode: 0o700 |
||||
|
}); |
||||
|
} else { |
||||
|
await fs.promises.chmod(fallbackDir, 0o700); |
||||
|
} |
||||
|
} catch (mkdirError) { |
||||
|
logger.error('Failed to create fallback directory:', mkdirError); |
||||
|
throw new Error('Could not create any suitable data directory'); |
||||
|
} |
||||
|
|
||||
|
return fallbackDir; |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
// Initialize database paths
|
||||
|
let dbPath: string | undefined; |
||||
|
let dbDir: string | undefined; |
||||
|
let dbPathInitialized = false; |
||||
|
let dbPathInitializationPromise: Promise<void> | null = null; |
||||
|
|
||||
|
const initializeDatabasePaths = async (): Promise<void> => { |
||||
|
if (dbPathInitializationPromise) return dbPathInitializationPromise; |
||||
|
if (dbPathInitialized) return; |
||||
|
|
||||
|
dbPathInitializationPromise = (async () => { |
||||
|
try { |
||||
|
// Get the app data directory in user's home
|
||||
|
const absolutePath = await getAppDataPath(); |
||||
|
logger.info('Absolute database path:', absolutePath); |
||||
|
|
||||
|
// For the plugin, we need to use a path relative to the electron folder
|
||||
|
// So we'll use a relative path from the electron folder to the home directory
|
||||
|
const electronPath = app.getAppPath(); |
||||
|
const relativeToElectron = path.relative(electronPath, absolutePath); |
||||
|
dbDir = relativeToElectron; |
||||
|
|
||||
|
logger.info('Database directory (relative to electron):', dbDir); |
||||
|
|
||||
|
// Ensure directory exists using absolute path
|
||||
|
if (!fs.existsSync(absolutePath)) { |
||||
|
await fs.promises.mkdir(absolutePath, { recursive: true }); |
||||
|
} |
||||
|
|
||||
|
// Use modern plugin conventions - no enforced extension
|
||||
|
const baseName = 'timesafariSQLite'; |
||||
|
dbPath = path.join(dbDir, baseName); |
||||
|
logger.info('Database path initialized (relative to electron):', dbPath); |
||||
|
|
||||
|
// Verify we can write to the directory using absolute path
|
||||
|
const testFile = path.join(absolutePath, '.write-test'); |
||||
|
try { |
||||
|
await fs.promises.writeFile(testFile, 'test'); |
||||
|
await fs.promises.unlink(testFile); |
||||
|
} catch (error) { |
||||
|
throw new Error(`Cannot write to database directory: ${error instanceof Error ? error.message : 'Unknown error'}`); |
||||
|
} |
||||
|
|
||||
|
// Set environment variable for the plugin using relative path
|
||||
|
process.env.CAPACITOR_SQLITE_DB_PATH = dbDir; |
||||
|
logger.info('Set CAPACITOR_SQLITE_DB_PATH:', process.env.CAPACITOR_SQLITE_DB_PATH); |
||||
|
|
||||
|
dbPathInitialized = true; |
||||
|
} catch (error) { |
||||
|
logger.error('Failed to initialize database paths:', error); |
||||
|
throw error; |
||||
|
} finally { |
||||
|
dbPathInitializationPromise = null; |
||||
|
} |
||||
|
})(); |
||||
|
|
||||
|
return dbPathInitializationPromise; |
||||
|
}; |
||||
|
|
||||
|
// Track initialization state
|
||||
|
let initializationError: Error | null = null; |
||||
|
|
||||
|
// Initialize SQLite plugin
|
||||
|
let sqlitePlugin: any = null; |
||||
|
let sqliteInitialized = false; |
||||
|
let sqliteInitializationPromise: Promise<void> | null = null; |
||||
|
|
||||
|
export async function initializeSQLite(): Promise<void> { |
||||
|
if (sqliteInitializationPromise) { |
||||
|
logger.info('SQLite initialization already in progress, waiting...'); |
||||
|
return sqliteInitializationPromise; |
||||
|
} |
||||
|
|
||||
|
if (sqliteInitialized) { |
||||
|
logger.info('SQLite already initialized'); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
sqliteInitializationPromise = (async () => { |
||||
|
try { |
||||
|
logger.info('Starting SQLite plugin initialization...'); |
||||
|
|
||||
|
// Initialize database paths first
|
||||
|
await initializeDatabasePaths(); |
||||
|
|
||||
|
if (!dbPath || !dbDir) { |
||||
|
throw new Error('Database path not initialized'); |
||||
|
} |
||||
|
|
||||
|
// Create plugin instance
|
||||
|
logger.info('Creating SQLite plugin instance...'); |
||||
|
sqlitePlugin = new CapacitorSQLite(); |
||||
|
|
||||
|
if (!sqlitePlugin) { |
||||
|
throw new Error('Failed to create SQLite plugin instance'); |
||||
|
} |
||||
|
|
||||
|
// Test the plugin
|
||||
|
logger.info('Testing SQLite plugin...'); |
||||
|
const echoResult = await sqlitePlugin.echo({ value: 'test' }); |
||||
|
if (!echoResult || echoResult.value !== 'test') { |
||||
|
throw new Error('SQLite plugin echo test failed'); |
||||
|
} |
||||
|
logger.info('SQLite plugin echo test successful'); |
||||
|
|
||||
|
// Initialize database connection using modern plugin conventions
|
||||
|
const connectionOptions = { |
||||
|
database: 'timesafariSQLite', |
||||
|
version: 1, |
||||
|
readOnly: false, |
||||
|
encryption: 'no-encryption', |
||||
|
useNative: true, |
||||
|
mode: 'rwc', |
||||
|
location: dbDir // Use path relative to electron folder
|
||||
|
}; |
||||
|
|
||||
|
logger.info('Creating initial database connection with options:', { |
||||
|
...connectionOptions, |
||||
|
expectedPath: dbPath // Path relative to electron folder
|
||||
|
}); |
||||
|
|
||||
|
const db = await sqlitePlugin.createConnection(connectionOptions); |
||||
|
|
||||
|
if (!db || typeof db !== 'object') { |
||||
|
throw new Error(`Failed to create database connection - invalid response. Path: ${dbPath}`); |
||||
|
} |
||||
|
|
||||
|
// Verify connection with a simple query
|
||||
|
logger.info('Verifying database connection...'); |
||||
|
try { |
||||
|
const result = await db.query({ statement: 'SELECT 1 as test;' }); |
||||
|
if (!result || !result.values || result.values.length === 0) { |
||||
|
throw new Error('Database connection test query returned no results'); |
||||
|
} |
||||
|
logger.info('Database connection verified successfully'); |
||||
|
} catch (error) { |
||||
|
throw new Error(`Database connection test failed: ${error instanceof Error ? error.message : 'Unknown error'}`); |
||||
|
} |
||||
|
|
||||
|
sqliteInitialized = true; |
||||
|
logger.info('SQLite plugin initialization completed successfully'); |
||||
|
} catch (error) { |
||||
|
logger.error('SQLite plugin initialization failed:', error); |
||||
|
// Store the error but don't throw
|
||||
|
initializationError = error instanceof Error ? error : new Error(String(error)); |
||||
|
// Reset state on failure but allow app to continue
|
||||
|
sqlitePlugin = null; |
||||
|
sqliteInitialized = false; |
||||
|
} finally { |
||||
|
sqliteInitializationPromise = null; |
||||
|
} |
||||
|
})(); |
||||
|
|
||||
|
return sqliteInitializationPromise; |
||||
|
} |
||||
|
|
||||
|
// Set up IPC handlers
|
||||
|
export function setupSQLiteHandlers(): void { |
||||
|
// Remove any existing handlers to prevent duplicates
|
||||
|
try { |
||||
|
ipcMain.removeHandler('sqlite-is-available'); |
||||
|
ipcMain.removeHandler('sqlite-echo'); |
||||
|
ipcMain.removeHandler('sqlite-create-connection'); |
||||
|
ipcMain.removeHandler('sqlite-execute'); |
||||
|
ipcMain.removeHandler('sqlite-query'); |
||||
|
ipcMain.removeHandler('sqlite-close-connection'); |
||||
|
ipcMain.removeHandler('sqlite-get-error'); |
||||
|
} catch (error) { |
||||
|
logger.warn('Error removing existing handlers:', error); |
||||
|
} |
||||
|
|
||||
|
// Register all handlers before any are called
|
||||
|
ipcMain.handle('sqlite-is-available', async () => { |
||||
|
try { |
||||
|
// Check both plugin instance and initialization state
|
||||
|
return sqlitePlugin !== null && sqliteInitialized; |
||||
|
} catch (error) { |
||||
|
logger.error('Error in sqlite-is-available:', error); |
||||
|
return false; |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
// Add handler to get initialization error
|
||||
|
ipcMain.handle('sqlite-get-error', async () => { |
||||
|
return initializationError ? { |
||||
|
message: initializationError.message, |
||||
|
stack: initializationError.stack, |
||||
|
name: initializationError.name |
||||
|
} : null; |
||||
|
}); |
||||
|
|
||||
|
// Update other handlers to handle unavailable state gracefully
|
||||
|
ipcMain.handle('sqlite-echo', async (_event, value) => { |
||||
|
try { |
||||
|
if (!sqlitePlugin || !sqliteInitialized) { |
||||
|
throw new Error('SQLite plugin not available'); |
||||
|
} |
||||
|
return await sqlitePlugin.echo({ value }); |
||||
|
} catch (error) { |
||||
|
logger.error('Error in sqlite-echo:', error); |
||||
|
throw error; |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
ipcMain.handle('sqlite-create-connection', async (_event, options) => { |
||||
|
try { |
||||
|
if (!sqlitePlugin || !sqliteInitialized) { |
||||
|
throw new Error('SQLite plugin not available'); |
||||
|
} |
||||
|
|
||||
|
if (!dbPath || !dbDir) { |
||||
|
throw new Error('Database path not initialized'); |
||||
|
} |
||||
|
|
||||
|
// Use modern plugin conventions for connection options
|
||||
|
const connectionOptions = { |
||||
|
...options, |
||||
|
database: 'timesafariSQLite', |
||||
|
readOnly: false, |
||||
|
mode: 'rwc', |
||||
|
encryption: 'no-encryption', |
||||
|
useNative: true, |
||||
|
location: dbDir // Use path relative to electron folder
|
||||
|
}; |
||||
|
|
||||
|
logger.info('Creating database connection with options:', connectionOptions); |
||||
|
const result = await sqlitePlugin.createConnection(connectionOptions); |
||||
|
|
||||
|
if (!result || typeof result !== 'object') { |
||||
|
throw new Error('Failed to create database connection - invalid response'); |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} catch (error) { |
||||
|
logger.error('Error in sqlite-create-connection:', error); |
||||
|
throw error; |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
ipcMain.handle('sqlite-execute', async (_event, options) => { |
||||
|
try { |
||||
|
if (!sqlitePlugin || !sqliteInitialized) { |
||||
|
throw new Error('SQLite plugin not available'); |
||||
|
} |
||||
|
return await sqlitePlugin.execute(options); |
||||
|
} catch (error) { |
||||
|
logger.error('Error in sqlite-execute:', error); |
||||
|
throw error; |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
ipcMain.handle('sqlite-query', async (_event, options) => { |
||||
|
try { |
||||
|
if (!sqlitePlugin || !sqliteInitialized) { |
||||
|
throw new Error('SQLite plugin not available'); |
||||
|
} |
||||
|
return await sqlitePlugin.query(options); |
||||
|
} catch (error) { |
||||
|
logger.error('Error in sqlite-query:', error); |
||||
|
throw error; |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
ipcMain.handle('sqlite-close-connection', async (_event, options) => { |
||||
|
try { |
||||
|
if (!sqlitePlugin || !sqliteInitialized) { |
||||
|
throw new Error('SQLite plugin not available'); |
||||
|
} |
||||
|
return await sqlitePlugin.closeConnection(options); |
||||
|
} catch (error) { |
||||
|
logger.error('Error in sqlite-close-connection:', error); |
||||
|
throw error; |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
logger.info('SQLite IPC handlers registered successfully'); |
||||
|
} |
||||
@ -0,0 +1,244 @@ |
|||||
|
import type { CapacitorElectronConfig } from '@capacitor-community/electron'; |
||||
|
import { |
||||
|
CapElectronEventEmitter, |
||||
|
CapacitorSplashScreen, |
||||
|
setupCapacitorElectronPlugins, |
||||
|
} from '@capacitor-community/electron'; |
||||
|
import chokidar from 'chokidar'; |
||||
|
import type { MenuItemConstructorOptions } from 'electron'; |
||||
|
import { app, BrowserWindow, Menu, MenuItem, nativeImage, Tray, session } from 'electron'; |
||||
|
import electronIsDev from 'electron-is-dev'; |
||||
|
import electronServe from 'electron-serve'; |
||||
|
import windowStateKeeper from 'electron-window-state'; |
||||
|
import { join } from 'path'; |
||||
|
|
||||
|
// Define components for a watcher to detect when the webapp is changed so we can reload in Dev mode.
|
||||
|
const reloadWatcher = { |
||||
|
debouncer: null, |
||||
|
ready: false, |
||||
|
watcher: null, |
||||
|
}; |
||||
|
export function setupReloadWatcher(electronCapacitorApp: ElectronCapacitorApp): void { |
||||
|
reloadWatcher.watcher = chokidar |
||||
|
.watch(join(app.getAppPath(), 'app'), { |
||||
|
ignored: /[/\\]\./, |
||||
|
persistent: true, |
||||
|
}) |
||||
|
.on('ready', () => { |
||||
|
reloadWatcher.ready = true; |
||||
|
}) |
||||
|
.on('all', (_event, _path) => { |
||||
|
if (reloadWatcher.ready) { |
||||
|
clearTimeout(reloadWatcher.debouncer); |
||||
|
reloadWatcher.debouncer = setTimeout(async () => { |
||||
|
electronCapacitorApp.getMainWindow().webContents.reload(); |
||||
|
reloadWatcher.ready = false; |
||||
|
clearTimeout(reloadWatcher.debouncer); |
||||
|
reloadWatcher.debouncer = null; |
||||
|
reloadWatcher.watcher = null; |
||||
|
setupReloadWatcher(electronCapacitorApp); |
||||
|
}, 1500); |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
// Define our class to manage our app.
|
||||
|
export class ElectronCapacitorApp { |
||||
|
private MainWindow: BrowserWindow | null = null; |
||||
|
private SplashScreen: CapacitorSplashScreen | null = null; |
||||
|
private TrayIcon: Tray | null = null; |
||||
|
private CapacitorFileConfig: CapacitorElectronConfig; |
||||
|
private TrayMenuTemplate: (MenuItem | MenuItemConstructorOptions)[] = [ |
||||
|
new MenuItem({ label: 'Quit App', role: 'quit' }), |
||||
|
]; |
||||
|
private AppMenuBarMenuTemplate: (MenuItem | MenuItemConstructorOptions)[] = [ |
||||
|
{ role: process.platform === 'darwin' ? 'appMenu' : 'fileMenu' }, |
||||
|
{ role: 'viewMenu' }, |
||||
|
]; |
||||
|
private mainWindowState; |
||||
|
private loadWebApp; |
||||
|
private customScheme: string; |
||||
|
|
||||
|
constructor( |
||||
|
capacitorFileConfig: CapacitorElectronConfig, |
||||
|
trayMenuTemplate?: (MenuItemConstructorOptions | MenuItem)[], |
||||
|
appMenuBarMenuTemplate?: (MenuItemConstructorOptions | MenuItem)[] |
||||
|
) { |
||||
|
this.CapacitorFileConfig = capacitorFileConfig; |
||||
|
|
||||
|
this.customScheme = this.CapacitorFileConfig.electron?.customUrlScheme ?? 'capacitor-electron'; |
||||
|
|
||||
|
if (trayMenuTemplate) { |
||||
|
this.TrayMenuTemplate = trayMenuTemplate; |
||||
|
} |
||||
|
|
||||
|
if (appMenuBarMenuTemplate) { |
||||
|
this.AppMenuBarMenuTemplate = appMenuBarMenuTemplate; |
||||
|
} |
||||
|
|
||||
|
// Setup our web app loader, this lets us load apps like react, vue, and angular without changing their build chains.
|
||||
|
this.loadWebApp = electronServe({ |
||||
|
directory: join(app.getAppPath(), 'app'), |
||||
|
scheme: this.customScheme, |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
// Helper function to load in the app.
|
||||
|
private async loadMainWindow(thisRef: any) { |
||||
|
await thisRef.loadWebApp(thisRef.MainWindow); |
||||
|
} |
||||
|
|
||||
|
// Expose the mainWindow ref for use outside of the class.
|
||||
|
getMainWindow(): BrowserWindow { |
||||
|
return this.MainWindow; |
||||
|
} |
||||
|
|
||||
|
getCustomURLScheme(): string { |
||||
|
return this.customScheme; |
||||
|
} |
||||
|
|
||||
|
async init(): Promise<void> { |
||||
|
const icon = nativeImage.createFromPath( |
||||
|
join(app.getAppPath(), 'assets', process.platform === 'win32' ? 'appIcon.ico' : 'appIcon.png') |
||||
|
); |
||||
|
this.mainWindowState = windowStateKeeper({ |
||||
|
defaultWidth: 1000, |
||||
|
defaultHeight: 800, |
||||
|
}); |
||||
|
// Setup preload script path and construct our main window.
|
||||
|
const preloadPath = join(app.getAppPath(), 'build', 'src', 'preload.js'); |
||||
|
this.MainWindow = new BrowserWindow({ |
||||
|
icon, |
||||
|
show: false, |
||||
|
x: this.mainWindowState.x, |
||||
|
y: this.mainWindowState.y, |
||||
|
width: this.mainWindowState.width, |
||||
|
height: this.mainWindowState.height, |
||||
|
webPreferences: { |
||||
|
nodeIntegration: true, |
||||
|
contextIsolation: true, |
||||
|
// Use preload to inject the electron varriant overrides for capacitor plugins.
|
||||
|
// preload: join(app.getAppPath(), "node_modules", "@capacitor-community", "electron", "dist", "runtime", "electron-rt.js"),
|
||||
|
preload: preloadPath, |
||||
|
}, |
||||
|
}); |
||||
|
this.mainWindowState.manage(this.MainWindow); |
||||
|
|
||||
|
if (this.CapacitorFileConfig.backgroundColor) { |
||||
|
this.MainWindow.setBackgroundColor(this.CapacitorFileConfig.electron.backgroundColor); |
||||
|
} |
||||
|
|
||||
|
// If we close the main window with the splashscreen enabled we need to destory the ref.
|
||||
|
this.MainWindow.on('closed', () => { |
||||
|
if (this.SplashScreen?.getSplashWindow() && !this.SplashScreen.getSplashWindow().isDestroyed()) { |
||||
|
this.SplashScreen.getSplashWindow().close(); |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
// When the tray icon is enabled, setup the options.
|
||||
|
if (this.CapacitorFileConfig.electron?.trayIconAndMenuEnabled) { |
||||
|
this.TrayIcon = new Tray(icon); |
||||
|
this.TrayIcon.on('double-click', () => { |
||||
|
if (this.MainWindow) { |
||||
|
if (this.MainWindow.isVisible()) { |
||||
|
this.MainWindow.hide(); |
||||
|
} else { |
||||
|
this.MainWindow.show(); |
||||
|
this.MainWindow.focus(); |
||||
|
} |
||||
|
} |
||||
|
}); |
||||
|
this.TrayIcon.on('click', () => { |
||||
|
if (this.MainWindow) { |
||||
|
if (this.MainWindow.isVisible()) { |
||||
|
this.MainWindow.hide(); |
||||
|
} else { |
||||
|
this.MainWindow.show(); |
||||
|
this.MainWindow.focus(); |
||||
|
} |
||||
|
} |
||||
|
}); |
||||
|
this.TrayIcon.setToolTip(app.getName()); |
||||
|
this.TrayIcon.setContextMenu(Menu.buildFromTemplate(this.TrayMenuTemplate)); |
||||
|
} |
||||
|
|
||||
|
// Setup the main manu bar at the top of our window.
|
||||
|
Menu.setApplicationMenu(Menu.buildFromTemplate(this.AppMenuBarMenuTemplate)); |
||||
|
|
||||
|
// If the splashscreen is enabled, show it first while the main window loads then switch it out for the main window, or just load the main window from the start.
|
||||
|
if (this.CapacitorFileConfig.electron?.splashScreenEnabled) { |
||||
|
this.SplashScreen = new CapacitorSplashScreen({ |
||||
|
imageFilePath: join( |
||||
|
app.getAppPath(), |
||||
|
'assets', |
||||
|
this.CapacitorFileConfig.electron?.splashScreenImageName ?? 'splash.png' |
||||
|
), |
||||
|
windowWidth: 400, |
||||
|
windowHeight: 400, |
||||
|
}); |
||||
|
this.SplashScreen.init(this.loadMainWindow, this); |
||||
|
} else { |
||||
|
this.loadMainWindow(this); |
||||
|
} |
||||
|
|
||||
|
// Security
|
||||
|
this.MainWindow.webContents.setWindowOpenHandler((details) => { |
||||
|
if (!details.url.includes(this.customScheme)) { |
||||
|
return { action: 'deny' }; |
||||
|
} else { |
||||
|
return { action: 'allow' }; |
||||
|
} |
||||
|
}); |
||||
|
this.MainWindow.webContents.on('will-navigate', (event, _newURL) => { |
||||
|
if (!this.MainWindow.webContents.getURL().includes(this.customScheme)) { |
||||
|
event.preventDefault(); |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
// Link electron plugins into the system.
|
||||
|
setupCapacitorElectronPlugins(); |
||||
|
|
||||
|
// When the web app is loaded we hide the splashscreen if needed and show the mainwindow.
|
||||
|
this.MainWindow.webContents.on('dom-ready', () => { |
||||
|
if (this.CapacitorFileConfig.electron?.splashScreenEnabled) { |
||||
|
this.SplashScreen.getSplashWindow().hide(); |
||||
|
} |
||||
|
if (!this.CapacitorFileConfig.electron?.hideMainWindowOnLaunch) { |
||||
|
this.MainWindow.show(); |
||||
|
} |
||||
|
setTimeout(() => { |
||||
|
if (electronIsDev) { |
||||
|
this.MainWindow.webContents.openDevTools(); |
||||
|
} |
||||
|
CapElectronEventEmitter.emit('CAPELECTRON_DeeplinkListenerInitialized', ''); |
||||
|
}, 400); |
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Set a CSP up for our application based on the custom scheme
|
||||
|
export function setupContentSecurityPolicy(customScheme: string): void { |
||||
|
session.defaultSession.webRequest.onHeadersReceived((details, callback) => { |
||||
|
callback({ |
||||
|
responseHeaders: { |
||||
|
...details.responseHeaders, |
||||
|
'Content-Security-Policy': [ |
||||
|
// Base CSP for both dev and prod
|
||||
|
`default-src ${customScheme}://* 'unsafe-inline' data:;`, |
||||
|
// Allow Google Fonts
|
||||
|
`style-src ${customScheme}://* 'unsafe-inline' https://fonts.googleapis.com;`, |
||||
|
`font-src ${customScheme}://* https://fonts.gstatic.com;`, |
||||
|
// Allow images and media
|
||||
|
`img-src ${customScheme}://* data: https:;`, |
||||
|
// Allow connections to HTTPS resources
|
||||
|
`connect-src ${customScheme}://* https:;`, |
||||
|
// Add dev-specific policies
|
||||
|
...(electronIsDev ? [ |
||||
|
`script-src ${customScheme}://* 'unsafe-inline' 'unsafe-eval' devtools://*;`, |
||||
|
`default-src ${customScheme}://* 'unsafe-inline' devtools://* 'unsafe-eval' data:;` |
||||
|
] : []) |
||||
|
].join(' ') |
||||
|
}, |
||||
|
}); |
||||
|
}); |
||||
|
} |
||||
@ -0,0 +1,18 @@ |
|||||
|
{ |
||||
|
"compileOnSave": true, |
||||
|
"include": ["./src/**/*", "./capacitor.config.ts", "./capacitor.config.js"], |
||||
|
"compilerOptions": { |
||||
|
"outDir": "./build", |
||||
|
"importHelpers": true, |
||||
|
"target": "ES2020", |
||||
|
"module": "CommonJS", |
||||
|
"moduleResolution": "node", |
||||
|
"esModuleInterop": true, |
||||
|
"typeRoots": ["./node_modules/@types"], |
||||
|
"allowJs": true, |
||||
|
"rootDir": ".", |
||||
|
"skipLibCheck": true, |
||||
|
"resolveJsonModule": true |
||||
|
} |
||||
|
} |
||||
|
|
||||
Loading…
Reference in new issue