@lvce-editor/shared-process 0.21.1 → 0.21.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.21.1",
+  "version": "0.21.2",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -14,16 +14,16 @@
     "directory": "packages/shared-process"
   },
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "dependencies": {
     "@babel/code-frame": "^7.23.5",
-    "@lvce-editor/extension-host": "0.21.1",
-    "@lvce-editor/extension-host-helper-process": "0.21.1",
+    "@lvce-editor/extension-host": "0.21.2",
+    "@lvce-editor/extension-host-helper-process": "0.21.2",
     "@lvce-editor/json-rpc": "^0.4.0",
     "@lvce-editor/jsonc-parser": "^1.1.0",
     "@lvce-editor/pretty-error": "^1.2.2",
-    "@lvce-editor/pty-host": "0.21.1",
+    "@lvce-editor/pty-host": "0.21.2",
     "@lvce-editor/verror": "^1.1.2",
     "debug": "^4.3.4",
     "execa": "^8.0.1",

package/src/parts/AppWindow/AppWindow.js

@@ -1,42 +1,13 @@
 import * as DefaultUrl from '../DefaultUrl/DefaultUrl.js'
+import * as GetAppWindowOptions from '../GetAppWindowOptions/GetAppWindowOptions.js'
 import * as ParentIpc from '../ParentIpc/ParentIpc.js'
-import * as Platform from '../Platform/Platform.js'
 import * as Preferences from '../Preferences/Preferences.js'
 import * as Screen from '../Screen/Screen.js'
 
-const getWindowOptions = (preferencs, screenWidth, screenHeight) => {
-  const titleBarPreference = preferencs['window.titleBarStyle']
-  const frame = titleBarPreference !== 'custom'
-  const titleBarStyle = titleBarPreference === 'custom' ? 'hidden' : undefined
-  const zoomLevelPreference = preferencs['window.zoomLevel']
-  const zoomLevel = zoomLevelPreference
-  const windowControlsOverlayPreference = Platform.isWindows && preferencs['window.controlsOverlay.enabled']
-
-  const titleBarOverlay = windowControlsOverlayPreference
-    ? {
-        color: '#1e2324',
-        symbolColor: '#74b1be',
-        height: 29,
-      }
-    : undefined
-  return {
-    y: 0,
-    x: screenWidth - 800,
-    width: 800,
-    height: screenHeight,
-    menu: true,
-    background: '#1e2324',
-    titleBarStyle,
-    frame,
-    zoomLevel,
-    titleBarOverlay,
-  }
-}
-
 export const createAppWindow = async (preferences, parsedArgs, workingDirectory, url = DefaultUrl.defaultUrl) => {
   const screenWidth = await Screen.getWidth()
   const screenHeight = await Screen.getHeight()
-  const windowOptions = getWindowOptions(preferences, screenWidth, screenHeight)
+  const windowOptions = GetAppWindowOptions.getAppWindowOptions(preferences, screenWidth, screenHeight)
   return ParentIpc.invoke('AppWindow.createAppWindow2', windowOptions, parsedArgs, workingDirectory, url)
 }
 

package/src/parts/Clamp/Clamp.js

@@ -0,0 +1,3 @@
+export const clamp = (number_, min, max) => {
+  return Math.min(Math.max(number_, min), max)
+}

package/src/parts/ElectronWindow/ElectronWindow.js

@@ -1,6 +1,7 @@
+import * as AppWindow from '../AppWindow/AppWindow.js'
 import * as Assert from '../Assert/Assert.js'
+import * as Clamp from '../Clamp/Clamp.js'
 import * as ParentIpc from '../ParentIpc/ParentIpc.js'
-import * as AppWindow from '../AppWindow/AppWindow.js'
 
 export const openNew = () => {
   return AppWindow.openNew()
@@ -36,16 +37,59 @@ export const reload = (windowId) => {
   return ParentIpc.invoke('ElectronWindow.executeWindowFunction', windowId, 'reload')
 }
 
+const setZoom = async (windowId, zoomFactor, minZoomLevel, maxZoomLevel) => {
+  const newZoomFactor = Clamp.clamp(zoomFactor, minZoomLevel, maxZoomLevel)
+  await ParentIpc.invoke('ElectronWindow.executeWebContentsFunction', windowId, 'setZoomLevel', newZoomFactor)
+  // TODO
+  // await Preferences.update('window.zoomLevel', newZoomFactor)
+}
+
+/**
+ *
+ * @param {number} windowId
+ * @param {*} getDelta
+ * @param {*} getMinZoomLevel
+ * @param {*} getMaxZoomLevel
+ * @returns
+ */
+const setZoomDelta = async (windowId, getDelta, getMinZoomLevel, getMaxZoomLevel) => {
+  const delta = getDelta()
+  const minZoomLevel = getMinZoomLevel()
+  const maxZoomLevel = getMaxZoomLevel()
+  const currentZoomLevel = await ParentIpc.invoke('ElectronWindow.executeWebContentsFunction', windowId, 'getZoomLevel')
+  return setZoom(windowId, currentZoomLevel + delta, minZoomLevel, maxZoomLevel)
+}
+
+const getMinZoomLevel = () => {
+  return -3
+}
+
+const getMaxZoomLevel = () => {
+  return 3
+}
+
+const getZoomInDelta = () => {
+  return 0.2
+}
+
+const getZoomOutDelta = () => {
+  return -0.2
+}
+
+const getDefaultZoomLevel = () => {
+  return 0
+}
+
 export const zoomIn = (windowId) => {
-  return ParentIpc.invoke('ElectronWindow.zoomIn', windowId)
+  return setZoomDelta(windowId, getZoomInDelta, getMinZoomLevel, getMaxZoomLevel)
 }
 
 export const zoomOut = (windowId) => {
-  return ParentIpc.invoke('ElectronWindow.zoomOut', windowId)
+  return setZoomDelta(windowId, getZoomOutDelta, getMinZoomLevel, getMaxZoomLevel)
 }
 
 export const zoomReset = (windowId) => {
-  return ParentIpc.invoke('ElectronWindow.zoomReset', windowId)
+  return setZoom(windowId, getDefaultZoomLevel(), getMinZoomLevel(), getMaxZoomLevel())
 }
 
 export const focus = (windowId) => {

package/src/parts/ErrorHandling/ErrorHandling.js

@@ -58,7 +58,7 @@ const firstErrorLine = (error) => {
 }
 
 export const handleUncaughtExceptionMonitor = (error, origin) => {
-  Logger.info(`[shared process] uncaught exception: ${firstErrorLine(error)}`)
+  Logger.info(`[shared process] Uncaught exception: ${firstErrorLine(error)}`)
   if (IsIgnoredError.isIgnoredError(error)) {
     return
   }

package/src/parts/GetAppWindowOptions/GetAppWindowOptions.js

@@ -0,0 +1,29 @@
+import * as GetBrowserWindowOptions from '../GetBrowserWindowOptions/GetBrowserWindowOptions.js'
+import * as Platform from '../Platform/Platform.js'
+
+export const getAppWindowOptions = (preferences, screenWidth, screenHeight) => {
+  const titleBarPreference = preferences['window.titleBarStyle']
+  const frame = titleBarPreference !== 'custom'
+  const titleBarStyle = titleBarPreference === 'custom' ? 'hidden' : undefined
+  const zoomLevelPreference = preferences['window.zoomLevel']
+  const zoomLevel = zoomLevelPreference
+  const windowControlsOverlayPreference = Platform.isWindows && preferences['window.controlsOverlay.enabled']
+
+  const titleBarOverlay = windowControlsOverlayPreference
+    ? {
+        color: '#1e2324',
+        symbolColor: '#74b1be',
+        height: 29,
+      }
+    : undefined
+  return GetBrowserWindowOptions.getBrowserWindowOptions({
+    y: 0,
+    x: screenWidth - 800,
+    width: 800,
+    height: screenHeight,
+    background: '#1e2324',
+    titleBarStyle,
+    frame,
+    titleBarOverlay,
+  })
+}

package/src/parts/GetBrowserWindowOptions/GetBrowserWindowOptions.js

@@ -0,0 +1,32 @@
+import * as GetIcon from '../GetIcon/GetIcon.js'
+import * as GetPreloadUrl from '../GetPreloadUrl/GetPreloadUrl.js'
+
+/**
+ *
+ * @returns {any}
+ */
+export const getBrowserWindowOptions = ({ x, y, width, height, titleBarStyle, titleBarOverlay, frame, background }) => {
+  const icon = GetIcon.getIcon()
+  return {
+    x,
+    y,
+    width,
+    height,
+    autoHideMenuBar: true,
+    titleBarStyle,
+    titleBarOverlay,
+    frame,
+    webPreferences: {
+      enableWebSQL: false,
+      spellcheck: false,
+      sandbox: true,
+      contextIsolation: true,
+      v8CacheOptions: 'bypassHeatCheck', // TODO this is what vscode uses, but it doesn't work properly in electron https://github.com/electron/electron/issues/27075
+      preload: GetPreloadUrl.getPreloadUrl(),
+      additionalArguments: ['--lvce-window-kind'],
+    },
+    backgroundColor: background,
+    show: false,
+    icon,
+  }
+}

package/src/parts/GetIcon/GetIcon.js

@@ -0,0 +1,19 @@
+import * as Path from '../Path/Path.js'
+import * as Platform from '../Platform/Platform.js'
+import * as Root from '../Root/Root.js'
+
+export const getIcon = () => {
+  if (!Platform.isProduction && Platform.isLinux) {
+    return Path.join(Root.root, 'build', 'files', 'icon.png')
+  }
+  if (!Platform.isProduction && Platform.isWindows) {
+    return Path.join(Root.root, 'build', 'files', 'icon.png')
+  }
+  if (Platform.isProduction && Platform.isArchLinux) {
+    return Path.join(Root.root, 'static', 'icons', 'icon.png')
+  }
+  if (Platform.isProduction && Platform.isAppImage) {
+    return Path.join(Root.root, 'static', 'icons', 'icon.png')
+  }
+  return undefined
+}

package/src/parts/GetPreloadUrl/GetPreloadUrl.js

@@ -0,0 +1,6 @@
+import { join } from 'node:path'
+import * as Root from '../Root/Root.js'
+
+export const getPreloadUrl = () => {
+  return join(Root.root, 'packages', 'main-process', 'src', 'preload.js')
+}

package/src/parts/GetProcessExplorerUrl/GetProcessExplorerUrl.js

@@ -7,5 +7,5 @@ export const getProcessExplorerUrl = () => {
 }
 
 export const getProcessExplorerPreloadUrl = () => {
-  return Path.join(Root.root, 'packages', 'main-process', 'pages', 'process-explorer', 'process-explorer-preload.js')
+  return Path.join(Root.root, 'packages', 'main-process', 'src', 'preload.js')
 }

package/src/parts/HandleIpc/HandleIpc.js

@@ -16,7 +16,6 @@ const logError = (error, prettyError) => {
 
 export const handleIpc = (ipc) => {
   const handleMessage = (message) => {
-    // @ts-ignore
     return JsonRpc.handleJsonRpcMessage(ipc, message, Command.execute, Callback.resolve, preparePrettyError, logError, RequiresSocket.requiresSocket)
   }
   ipc.on('message', handleMessage)

package/src/parts/HandleMessagePortForTerminalProcess/HandleMessagePortForTerminalProcess.ipc.js

@@ -0,0 +1,7 @@
+import * as HandleMessagePortForTerminalProcess from './HandleMessagePortForTerminalProcess.js'
+
+export const name = 'HandleMessagePortForTerminalProcess'
+
+export const Commands = {
+  handleMessagePortForTerminalProcess: HandleMessagePortForTerminalProcess.handleMessagePortForTerminalProcess,
+}

package/src/parts/HandleMessagePortForTerminalProcess/HandleMessagePortForTerminalProcess.js

@@ -0,0 +1,10 @@
+import * as Assert from '../Assert/Assert.js'
+import * as IpcParentType from '../IpcParentType/IpcParentType.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+import * as PtyHost from '../PtyHost/PtyHost.js'
+
+export const handleMessagePortForTerminalProcess = async (port) => {
+  Assert.object(port)
+  const ptyHost = await PtyHost.getOrCreate(IpcParentType.ElectronUtilityProcess)
+  await JsonRpc.invokeAndTransfer(ptyHost, [port], 'HandleElectronMessagePort.handleElectronMessagePort')
+}

package/src/parts/HandleUncaughtExceptionMonitor/HandleUncaughtExceptionMonitor.js

@@ -1,5 +1,15 @@
 import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
 
-export const handleUncaughtExceptionMonitor = (error) => {
+const handleUncaughtExceptionMonitor = (error) => {
   ErrorHandling.handleUncaughtExceptionMonitor(error)
 }
+
+export const handleUncaughtException = (error) => {
+  handleUncaughtExceptionMonitor(error)
+  process.exit(1)
+}
+
+export const handleUnhandledRejection = (error) => {
+  handleUncaughtExceptionMonitor(error)
+  process.exit(1)
+}

package/src/parts/IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js

@@ -9,7 +9,14 @@ export const listen = ({ messagePort }) => {
 }
 
 const getActualData = (event) => {
-  return event.data
+  const { data, ports } = event
+  if (ports.length === 0) {
+    return data
+  }
+  return {
+    ...data,
+    params: [...ports, ...data.params],
+  }
 }
 
 export const wrap = (messagePort) => {

package/src/parts/IpcChildWithElectronUtilityProcess/IpcChildWithElectronUtilityProcess.js

@@ -44,6 +44,9 @@ export const wrap = (parentPort) => {
     send(message) {
       this.parentPort.postMessage(message)
     },
+    sendAndTransfer(message, transfer) {
+      this.parentPort.postMessage(message, transfer)
+    },
     dispose() {
       this.parentPort.close()
     },

package/src/parts/IpcParentModule/IpcParentModule.js

@@ -6,6 +6,8 @@ export const getModule = (method) => {
       return import('../IpcParentWithNodeWorker/IpcParentWithNodeWorker.js')
     case IpcParentType.NodeForkedProcess:
       return import('../IpcParentWithNodeForkedProcess/IpcParentWithNodeForkedProcess.js')
+    case IpcParentType.ElectronUtilityProcess:
+      return import('../IpcParentWithElectronUtilityProcess/IpcParentWithElectronUtilityProcess.js')
     default:
       throw new Error('unexpected ipc type')
   }

package/src/parts/IpcParentWithElectronUtilityProcess/IpcParentWithElectronUtilityProcess.js

@@ -1,12 +1,48 @@
 import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+import * as TemporaryMessagePort from '../TemporaryMessagePort/TemporaryMessagePort.js'
+
+const ElectronUtilityProcess = 3
 
 export const create = async (options) => {
   // TODO how to launch process without race condition?
   // when promise resolves, process might have already exited
-  const messagePort = await ParentIpc.invoke('IpcParent.create', { ...options })
-  return messagePort
+  await ParentIpc.invoke('IpcParent.create', {
+    ...options,
+    method: ElectronUtilityProcess,
+    noReturn: true,
+  })
+  // TODO use uuid instead of name
+  const port = await TemporaryMessagePort.create(options.name)
+  return port
 }
 
-export const wrap = (messagePort) => {
-  return {}
+export const wrap = (port) => {
+  return {
+    port,
+    send(message) {
+      this.port.postMessage(message)
+    },
+    async sendAndTransfer(message, transfer) {
+      this.port.postMessage(message, transfer)
+    },
+    on(event, listener) {
+      switch (event) {
+        case 'close':
+          this.port.on(event, listener)
+          break
+        case 'message':
+          const wrapped = (event) => {
+            listener(event.data)
+          }
+          this.port.on(event, wrapped)
+          break
+        default:
+          break
+      }
+    },
+    off(event, listener) {},
+    dispose() {
+      this.port.close()
+    },
+  }
 }

package/src/parts/Main/Main.js

@@ -9,6 +9,7 @@ export const main = async () => {
   Command.setLoad(Module.load)
   process.on('disconnect', ProcessListeners.handleDisconnect)
   process.on(Signal.SIGTERM, ProcessListeners.handleSigTerm)
-  process.on('uncaughtExceptionMonitor', HandleUncaughtExceptionMonitor.handleUncaughtExceptionMonitor)
+  process.on('uncaughtException', HandleUncaughtExceptionMonitor.handleUncaughtException)
+  process.on('unhandledRejection', HandleUncaughtExceptionMonitor.handleUnhandledRejection)
   await ParentIpc.listen()
 }

package/src/parts/Module/Module.js

@@ -130,6 +130,10 @@ export const load = (moduleId) => {
       return import('../HandleElectronReady/HandleElectronReady.ipc.js')
     case ModuleId.HandleWindowAllClosed:
       return import('../HandleWindowAllClosed/HandleWindowAllClosed.ipc.js')
+    case ModuleId.HandleMessagePortForTerminalProcess:
+      return import('../HandleMessagePortForTerminalProcess/HandleMessagePortForTerminalProcess.ipc.js')
+    case ModuleId.TemporaryMessagePort:
+      return import('../TemporaryMessagePort/TemporaryMessagePort.ipc.js')
     default:
       throw new Error(`module ${moduleId} not found`)
   }

package/src/parts/ModuleId/ModuleId.js

@@ -64,3 +64,5 @@ export const ElectronNet = 57
 export const Screen = 58
 export const HandleElectronReady = 59
 export const HandleWindowAllClosed = 60
+export const HandleMessagePortForTerminalProcess = 61
+export const TemporaryMessagePort = 62

package/src/parts/ModuleMap/ModuleMap.js

@@ -285,6 +285,10 @@ export const getModuleId = (commandId) => {
       return ModuleId.HandleElectronReady
     case 'HandleWindowAllClosed.handleWindowAllClosed':
       return ModuleId.HandleWindowAllClosed
+    case 'HandleMessagePortForTerminalProcess.handleMessagePortForTerminalProcess':
+      return ModuleId.HandleMessagePortForTerminalProcess
+    case 'TemporaryMessagePort.handlePort':
+      return ModuleId.TemporaryMessagePort
     default:
       throw new CommandNotFoundError(commandId)
   }

package/src/parts/ParentIpc/ParentIpc.js

@@ -28,3 +28,6 @@ export const listen = async () => {
 export const invoke = (method, ...params) => {
   return JsonRpc.invoke(state.ipc, method, ...params)
 }
+export const invokeAndTransfer = (method, transfer, ...params) => {
+  return JsonRpc.invokeAndTransfer(state.ipc, transfer, method, ...params)
+}

package/src/parts/Platform/Platform.js

@@ -13,6 +13,14 @@ export const isMacOs = platform === 'darwin'
 
 export const isDeb = false
 
+export const isLinux = platform === 'linux'
+
+export const isProduction = false
+
+export const isArchLinux = false
+
+export const isAppImage = false
+
 export const scheme = 'lvce-oss'
 
 export const getPathSeparator = () => {
@@ -53,11 +61,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.21.1'
+export const version = '0.21.2'
 
-export const commit = '1aea3f8'
+export const commit = 'ba057bc'
 
-export const date = '2023-12-12T20:15:17.000Z'
+export const date = '2023-12-15T19:39:33.000Z'
 
 export const getVersion = () => {
   return version

package/src/parts/PtyHost/PtyHost.js

@@ -1,5 +1,6 @@
 import exitHook from 'exit-hook'
 import * as Debug from '../Debug/Debug.js'
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
 import * as IpcParent from '../IpcParent/IpcParent.js'
 import * as IpcParentType from '../IpcParentType/IpcParentType.js'
 import * as JsonRpc from '../JsonRpc/JsonRpc.js'
@@ -18,16 +19,17 @@ const handleProcessExit = () => {
   cleanUpAll()
 }
 
-const createPtyHost = async () => {
+const createPtyHost = async (method) => {
   exitHook(handleProcessExit)
   const ptyHostPath = await PtyHostPath.getPtyHostPath()
   const ptyHost = await IpcParent.create({
-    method: IpcParentType.NodeForkedProcess,
+    method,
     path: ptyHostPath,
     argv: [],
     stdio: 'inherit',
     name: 'Terminal Process',
   })
+  HandleIpc.handleIpc(ptyHost)
   const handleClose = () => {
     ptyHost.off('close', handleClose)
     PtyHostState.state.ipc = undefined
@@ -38,10 +40,10 @@ const createPtyHost = async () => {
   return ptyHost
 }
 
-export const getOrCreate = () => {
+export const getOrCreate = (method = IpcParentType.NodeForkedProcess) => {
   Debug.debug('creating pty host')
   if (!PtyHostState.state.ptyHostPromise) {
-    PtyHostState.state.ptyHostPromise = createPtyHost()
+    PtyHostState.state.ptyHostPromise = createPtyHost(method)
   }
   return PtyHostState.state.ptyHostPromise
 }

package/src/parts/TemporaryMessagePort/TemporaryMessagePort.ipc.js

@@ -0,0 +1,7 @@
+import * as TemporaryMessagePort from './TemporaryMessagePort.js'
+
+export const name = 'TemporaryMessagePort'
+
+export const Commands = {
+  handlePort: TemporaryMessagePort.handlePort,
+}

package/src/parts/TemporaryMessagePort/TemporaryMessagePort.js

@@ -0,0 +1,24 @@
+import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+import * as Assert from '../Assert/Assert.js'
+
+export const state = {
+  ports: Object.create(null),
+}
+
+export const create = async (name) => {
+  Assert.string(name)
+  await ParentIpc.invoke('TemporaryMessagePort.create', name)
+  const port = state.ports[name]
+  if (!port) {
+    throw new Error(`port was not created`)
+  }
+  delete state.ports[name]
+  port.start()
+  return port
+}
+
+export const handlePort = (port, name) => {
+  Assert.string(name)
+  Assert.object(port)
+  state.ports[name] = port
+}