Tom Butcher
c5d8d9cf70
All checks were successful
farmcontrol/farmcontrol-ui/pipeline/head This commit looks good
476 lines
13 KiB
JavaScript
476 lines
13 KiB
JavaScript
import { createContext, useCallback, useEffect, useRef, useState } from 'react'
|
|
import PropTypes from 'prop-types'
|
|
import { useNavigate } from 'react-router-dom'
|
|
import desktopBridge, {
|
|
isElectrobunBridgeReady,
|
|
isElectrobunDesktop
|
|
} from '../../../electrobun-bridge.js'
|
|
|
|
const electron = window.require ? window.require('electron') : null
|
|
const ipcRenderer = electron ? electron.ipcRenderer : null
|
|
|
|
// eslint-disable-next-line react-refresh/only-export-components
|
|
export function isElectron() {
|
|
if (isElectrobunDesktop()) {
|
|
return true
|
|
}
|
|
|
|
if (
|
|
typeof window !== 'undefined' &&
|
|
window.process &&
|
|
window.process.type === 'renderer'
|
|
) {
|
|
return true
|
|
}
|
|
|
|
if (
|
|
typeof navigator === 'object' &&
|
|
typeof navigator.userAgent === 'string' &&
|
|
navigator.userAgent.indexOf('Electron') >= 0
|
|
) {
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
const ElectronContext = createContext()
|
|
|
|
function isInHorizontalScrollContainer(element) {
|
|
let node = element
|
|
while (node && node !== document.body) {
|
|
const { overflowX } = window.getComputedStyle(node)
|
|
if (
|
|
(overflowX === 'auto' || overflowX === 'scroll') &&
|
|
node.scrollWidth > node.clientWidth
|
|
) {
|
|
return true
|
|
}
|
|
node = node.parentElement
|
|
}
|
|
return false
|
|
}
|
|
|
|
const ElectronProvider = ({ children }) => {
|
|
const [platform, setPlatform] = useState('unknown')
|
|
const [isMaximized, setIsMaximized] = useState(false)
|
|
const [isFullScreen, setIsFullScreen] = useState(false)
|
|
const [electronAvailable] = useState(isElectron())
|
|
const useElectrobun = isElectrobunBridgeReady() || isElectrobunDesktop()
|
|
const navigate = useNavigate()
|
|
const lastNavigationAtRef = useRef(0)
|
|
|
|
const navigateHistory = useCallback(
|
|
(direction) => {
|
|
const now = Date.now()
|
|
if (now - lastNavigationAtRef.current < 300) return
|
|
lastNavigationAtRef.current = now
|
|
|
|
if (direction === 'back') {
|
|
navigate(-1)
|
|
} else if (direction === 'forward') {
|
|
navigate(1)
|
|
}
|
|
},
|
|
[navigate]
|
|
)
|
|
|
|
const applyWindowState = useCallback((state) => {
|
|
if (state && typeof state.isMaximized === 'boolean') {
|
|
setIsMaximized(state.isMaximized)
|
|
}
|
|
if (state && typeof state.isFullScreen === 'boolean') {
|
|
setIsFullScreen(state.isFullScreen)
|
|
}
|
|
}, [])
|
|
|
|
const openExternalUrl = (url) => {
|
|
if (useElectrobun) {
|
|
void desktopBridge.openExternalUrl(url).catch((error) => {
|
|
console.warn('[ElectronContext] Failed to open external url:', error)
|
|
})
|
|
return true
|
|
}
|
|
if (electronAvailable && ipcRenderer) {
|
|
ipcRenderer.invoke('open-external-url', url)
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
const openInternalUrl = (url) => {
|
|
if (useElectrobun) {
|
|
void desktopBridge.openInternalUrl(url).catch((error) => {
|
|
console.warn('[ElectronContext] Failed to open internal url:', error)
|
|
})
|
|
return true
|
|
}
|
|
if (electronAvailable && ipcRenderer) {
|
|
ipcRenderer.invoke('open-internal-url', url)
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
useEffect(() => {
|
|
if (!electronAvailable) return
|
|
|
|
if (useElectrobun) {
|
|
desktopBridge.getOsInfo().then((info) => {
|
|
if (info?.platform) {
|
|
setPlatform(info.platform)
|
|
if (info.platform === 'darwin') {
|
|
document.documentElement.classList.add('macos-vibrancy')
|
|
}
|
|
}
|
|
})
|
|
|
|
desktopBridge.getWindowState().then(applyWindowState)
|
|
|
|
const unsubWindowState = desktopBridge.onMessage(
|
|
'windowState',
|
|
applyWindowState
|
|
)
|
|
const unsubNavigate = desktopBridge.onMessage('navigate', (url) => {
|
|
if (url.toLowerCase() == '/favicon.ico') {
|
|
return
|
|
}
|
|
console.log('[ElectronContext] Navigating to:', url)
|
|
navigate(url)
|
|
})
|
|
const unsubNavigationGesture = desktopBridge.onMessage(
|
|
'navigationGesture',
|
|
navigateHistory
|
|
)
|
|
|
|
return () => {
|
|
unsubWindowState()
|
|
unsubNavigate()
|
|
unsubNavigationGesture()
|
|
}
|
|
}
|
|
|
|
if (!ipcRenderer) return
|
|
|
|
ipcRenderer.invoke('os-info').then((info) => {
|
|
if (info?.platform) {
|
|
setPlatform(info.platform)
|
|
if (info.platform === 'darwin') {
|
|
document.documentElement.classList.add('macos-vibrancy')
|
|
}
|
|
}
|
|
})
|
|
|
|
ipcRenderer.invoke('window-state').then(applyWindowState)
|
|
|
|
const windowStateHandler = (_event, state) => {
|
|
applyWindowState(state)
|
|
}
|
|
ipcRenderer.on('window-state', windowStateHandler)
|
|
|
|
const navigateHandler = (_event, url) => {
|
|
if (url.toLowerCase() == '/favicon.ico') {
|
|
return
|
|
}
|
|
console.log('[ElectronContext] Navigating to:', url)
|
|
navigate(url)
|
|
}
|
|
ipcRenderer.on('navigate', navigateHandler)
|
|
|
|
const navigationGestureHandler = (_event, direction) => {
|
|
navigateHistory(direction)
|
|
}
|
|
ipcRenderer.on('navigation-gesture', navigationGestureHandler)
|
|
|
|
return () => {
|
|
ipcRenderer.removeListener('navigate', navigateHandler)
|
|
ipcRenderer.removeListener('navigation-gesture', navigationGestureHandler)
|
|
ipcRenderer.removeListener('window-state', windowStateHandler)
|
|
}
|
|
}, [
|
|
applyWindowState,
|
|
electronAvailable,
|
|
navigate,
|
|
navigateHistory,
|
|
useElectrobun
|
|
])
|
|
|
|
useEffect(() => {
|
|
if (!electronAvailable || platform !== 'darwin') return
|
|
|
|
let accumulatedDeltaX = 0
|
|
let resetTimer
|
|
|
|
const handleWheel = (event) => {
|
|
if (event.metaKey || event.ctrlKey || event.altKey || event.shiftKey)
|
|
return
|
|
if (Math.abs(event.deltaX) < Math.abs(event.deltaY)) return
|
|
if (Math.abs(event.deltaX) < 2) return
|
|
if (isInHorizontalScrollContainer(event.target)) return
|
|
|
|
accumulatedDeltaX += event.deltaX
|
|
clearTimeout(resetTimer)
|
|
resetTimer = setTimeout(() => {
|
|
if (Math.abs(accumulatedDeltaX) > 60) {
|
|
navigateHistory(accumulatedDeltaX > 0 ? 'forward' : 'back')
|
|
}
|
|
accumulatedDeltaX = 0
|
|
}, 80)
|
|
}
|
|
|
|
window.addEventListener('wheel', handleWheel, { passive: true })
|
|
|
|
return () => {
|
|
window.removeEventListener('wheel', handleWheel)
|
|
clearTimeout(resetTimer)
|
|
}
|
|
}, [electronAvailable, navigateHistory, platform])
|
|
|
|
const handleWindowControl = (action) => {
|
|
if (useElectrobun) {
|
|
void desktopBridge.windowControl(action)
|
|
return
|
|
}
|
|
if (electronAvailable && ipcRenderer) {
|
|
ipcRenderer.send('window-control', action)
|
|
}
|
|
}
|
|
|
|
const getAuthSession = async () => {
|
|
if (!electronAvailable) return null
|
|
if (useElectrobun) return await desktopBridge.getAuthSession()
|
|
if (!ipcRenderer) return null
|
|
return await ipcRenderer.invoke('auth-session-get')
|
|
}
|
|
|
|
const setAuthSession = async (session) => {
|
|
if (!electronAvailable) return false
|
|
if (useElectrobun) {
|
|
const result = await desktopBridge.setAuthSession(session)
|
|
return result?.ok ?? false
|
|
}
|
|
if (!ipcRenderer) return false
|
|
return await ipcRenderer.invoke('auth-session-set', session)
|
|
}
|
|
|
|
const clearAuthSession = async () => {
|
|
if (!electronAvailable) return false
|
|
if (useElectrobun) {
|
|
const result = await desktopBridge.clearAuthSession()
|
|
return result?.ok ?? false
|
|
}
|
|
if (!ipcRenderer) return false
|
|
return await ipcRenderer.invoke('auth-session-clear')
|
|
}
|
|
|
|
const getAppSettings = useCallback(async () => {
|
|
if (!electronAvailable) return {}
|
|
if (useElectrobun) return await desktopBridge.getAppSettings()
|
|
if (!ipcRenderer) return {}
|
|
return await ipcRenderer.invoke('app-settings-get')
|
|
}, [electronAvailable, useElectrobun])
|
|
|
|
const setAppSettings = useCallback(
|
|
async (settings) => {
|
|
if (!electronAvailable) return false
|
|
if (useElectrobun) {
|
|
const result = await desktopBridge.setAppSettings(settings)
|
|
return result?.ok ?? false
|
|
}
|
|
if (!ipcRenderer) return false
|
|
return await ipcRenderer.invoke('app-settings-set', settings)
|
|
},
|
|
[electronAvailable, useElectrobun]
|
|
)
|
|
|
|
const startAppUpdate = useCallback(
|
|
async (update) => {
|
|
if (!electronAvailable) return false
|
|
if (useElectrobun) {
|
|
const result = await desktopBridge.startAppUpdate(update)
|
|
return result?.ok ?? false
|
|
}
|
|
if (!ipcRenderer) return false
|
|
return await ipcRenderer.invoke('app-update-start', update)
|
|
},
|
|
[electronAvailable, useElectrobun]
|
|
)
|
|
|
|
const checkAppUpdateResult = useCallback(async () => {
|
|
if (!electronAvailable || !useElectrobun) return null
|
|
return await desktopBridge.checkAppUpdateResult()
|
|
}, [electronAvailable, useElectrobun])
|
|
|
|
const checkDuplicateInstallations = useCallback(async () => {
|
|
if (!electronAvailable || !useElectrobun) return null
|
|
return await desktopBridge.checkDuplicateInstallations()
|
|
}, [electronAvailable, useElectrobun])
|
|
|
|
const removeDuplicateInstallations = useCallback(async () => {
|
|
if (!electronAvailable || !useElectrobun) return false
|
|
const result = await desktopBridge.removeDuplicateInstallations()
|
|
return result?.ok ?? false
|
|
}, [electronAvailable, useElectrobun])
|
|
|
|
const onDuplicateInstallationsRemoved = useCallback(
|
|
(handler) => {
|
|
if (
|
|
!electronAvailable ||
|
|
!useElectrobun ||
|
|
typeof handler !== 'function'
|
|
) {
|
|
return () => {}
|
|
}
|
|
return desktopBridge.onMessage('duplicateInstallationsRemoved', handler)
|
|
},
|
|
[electronAvailable, useElectrobun]
|
|
)
|
|
|
|
const onAppUpdateProgress = useCallback(
|
|
(handler) => {
|
|
if (!electronAvailable || typeof handler !== 'function') {
|
|
return () => {}
|
|
}
|
|
|
|
if (useElectrobun) {
|
|
return desktopBridge.onMessage('appUpdateProgress', handler)
|
|
}
|
|
|
|
if (!ipcRenderer) return () => {}
|
|
|
|
const progressHandler = (_event, progress) => {
|
|
handler(progress)
|
|
}
|
|
|
|
ipcRenderer.on('app-update-progress', progressHandler)
|
|
|
|
return () => {
|
|
ipcRenderer.removeListener('app-update-progress', progressHandler)
|
|
}
|
|
},
|
|
[electronAvailable, useElectrobun]
|
|
)
|
|
|
|
const onCheckForUpdatesRequest = useCallback(
|
|
(handler) => {
|
|
if (!electronAvailable || typeof handler !== 'function') {
|
|
return () => {}
|
|
}
|
|
|
|
if (useElectrobun) {
|
|
return desktopBridge.onMessage('checkForUpdates', handler)
|
|
}
|
|
|
|
if (!ipcRenderer) return () => {}
|
|
|
|
const checkHandler = () => {
|
|
handler()
|
|
}
|
|
|
|
ipcRenderer.on('check-for-updates', checkHandler)
|
|
|
|
return () => {
|
|
ipcRenderer.removeListener('check-for-updates', checkHandler)
|
|
}
|
|
},
|
|
[electronAvailable, useElectrobun]
|
|
)
|
|
|
|
const getToken = async () => {
|
|
const session = await getAuthSession()
|
|
return session?.token || null
|
|
}
|
|
|
|
const setToken = async (token) => {
|
|
const session = (await getAuthSession()) || {}
|
|
return await setAuthSession({ ...session, token })
|
|
}
|
|
|
|
const resizeSpotlightWindow = async (height) => {
|
|
if (!electronAvailable) return false
|
|
try {
|
|
if (useElectrobun) {
|
|
const result = await desktopBridge.resizeSpotlightWindow(height)
|
|
return result?.ok ?? false
|
|
}
|
|
if (!ipcRenderer) return false
|
|
return await ipcRenderer.invoke('spotlight-window-resize', height)
|
|
} catch (error) {
|
|
console.warn(
|
|
'[ElectronContext] Failed to resize spotlight window:',
|
|
error
|
|
)
|
|
return false
|
|
}
|
|
}
|
|
|
|
const setSidebarViewMenu = useCallback(
|
|
async (sections) => {
|
|
if (!electronAvailable) return false
|
|
if (useElectrobun) {
|
|
const result = await desktopBridge.setSidebarViewMenu(sections)
|
|
return result?.ok ?? false
|
|
}
|
|
if (!ipcRenderer) return false
|
|
return await ipcRenderer.invoke('set-sidebar-view-menu', sections)
|
|
},
|
|
[electronAvailable, useElectrobun]
|
|
)
|
|
|
|
const getElectronVersion = useCallback(async () => {
|
|
if (!electronAvailable) return null
|
|
if (useElectrobun) return await desktopBridge.getAppVersion()
|
|
if (!ipcRenderer) return null
|
|
return await ipcRenderer.invoke('electron-version')
|
|
}, [electronAvailable, useElectrobun])
|
|
|
|
const getAppEngine = useCallback(async () => {
|
|
if (!electronAvailable) return 'native'
|
|
if (useElectrobun) {
|
|
const engine = await desktopBridge.getAppEngine()
|
|
return engine === 'chromium' ? 'chromium' : 'native'
|
|
}
|
|
return 'native'
|
|
}, [electronAvailable, useElectrobun])
|
|
|
|
return (
|
|
<ElectronContext.Provider
|
|
value={{
|
|
platform,
|
|
isMaximized,
|
|
isFullScreen,
|
|
isElectron: electronAvailable,
|
|
handleWindowControl,
|
|
openExternalUrl,
|
|
openInternalUrl,
|
|
getAuthSession,
|
|
setAuthSession,
|
|
clearAuthSession,
|
|
getAppSettings,
|
|
setAppSettings,
|
|
startAppUpdate,
|
|
checkAppUpdateResult,
|
|
checkDuplicateInstallations,
|
|
removeDuplicateInstallations,
|
|
onDuplicateInstallationsRemoved,
|
|
onAppUpdateProgress,
|
|
onCheckForUpdatesRequest,
|
|
getToken,
|
|
setToken,
|
|
resizeSpotlightWindow,
|
|
setSidebarViewMenu,
|
|
getElectronVersion,
|
|
getAppEngine
|
|
}}
|
|
>
|
|
{children}
|
|
</ElectronContext.Provider>
|
|
)
|
|
}
|
|
|
|
ElectronProvider.propTypes = {
|
|
children: PropTypes.node.isRequired
|
|
}
|
|
|
|
export { ElectronContext, ElectronProvider }
|