@lvce-editor/shared-process 0.22.7 → 0.23.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.22.7",
+  "version": "0.23.1",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -18,11 +18,12 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "^1.2.0",
-    "@lvce-editor/extension-host-helper-process": "0.22.7",
+    "@lvce-editor/extension-host-helper-process": "0.23.1",
+    "@lvce-editor/ipc": "^2.1.0",
     "@lvce-editor/json-rpc": "^1.0.0",
     "@lvce-editor/jsonc-parser": "^1.1.0",
-    "@lvce-editor/pretty-error": "^1.4.1",
-    "@lvce-editor/pty-host": "0.22.7",
+    "@lvce-editor/pretty-error": "^1.5.0",
+    "@lvce-editor/pty-host": "0.23.1",
     "@lvce-editor/verror": "^1.1.2",
     "@lvce-editor/web-socket-server": "^1.1.0",
     "debug": "^4.3.4",
@@ -31,7 +32,7 @@
     "got": "^13.0.0",
     "is-object": "^1.0.2",
     "p-queue": "^8.0.1",
-    "tar-fs": "^3.0.4",
+    "tar-fs": "^3.0.5",
     "xdg-basedir": "^5.1.0"
   },
   "optionalDependencies": {

package/src/parts/ElectronBrowserView/ElectronBrowserView.js

@@ -1,13 +1,24 @@
+import * as ElectronBrowserViewIpcState from '../ElectronBrowserViewIpcState/ElectronBrowserViewIpcState.js'
+import * as ElectronBrowserViewState from '../ElectronBrowserViewState/ElectronBrowserViewState.js'
+import * as ElectronWebContents from '../ElectronWebContents/ElectronWebContents.js'
 import * as ParentIpc from '../ParentIpc/ParentIpc.js'
 
-export const createBrowserView = (restoreId, fallthroughKeyBindings) => {
-  return ParentIpc.invoke('ElectronBrowserView.createBrowserView', restoreId, fallthroughKeyBindings)
+export const createBrowserView = async (ipc, restoreId, fallthroughKeyBindings) => {
+  const webContentsId = await ParentIpc.invoke('ElectronBrowserView.createBrowserView2', restoreId)
+  ElectronBrowserViewIpcState.add(webContentsId, ipc)
+  // TODO get window id from renderer worker
+  await ParentIpc.invoke('ElectronBrowserView.attachEventListeners', webContentsId)
+  await ParentIpc.invoke('ElectronBrowserViewFunctions.setBackgroundColor', webContentsId, 'white')
+  return webContentsId
 }
 
-export const disposeBrowserView = (id) => {
-  return ParentIpc.invoke('ElectronBrowserView.disposeBrowserView', id)
+export const disposeBrowserView = async (id) => {
+  ElectronBrowserViewState.remove(id)
+  await ParentIpc.invoke('ElectronBrowserView.disposeBrowserView', id)
+  await ElectronWebContents.dispose(id)
 }
 
-export const getAll = () => {
-  return ParentIpc.invoke('ElectronBrowserView.getAll')
+export const handleBrowserViewCreated = (id) => {
+  console.log('created', id)
+  ElectronBrowserViewState.add(id)
 }

package/src/parts/ElectronBrowserViewFunctions/ElectronBrowserViewFunctions.js

@@ -1,4 +1,5 @@
 import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+import * as ElectronWebContents from '../ElectronWebContents/ElectronWebContents.js'
 
 export const resizeBrowserView = (id, x, y, width, height) => {
   return ParentIpc.invoke('ElectronBrowserViewFunctions.resizeBrowserView', id, x, y, width, height)
@@ -8,25 +9,19 @@ export const setIframeSrc = async (id, iframeSrc) => {
   return ParentIpc.invoke('ElectronBrowserViewFunctions.setIframeSrc', id, iframeSrc)
 }
 
-export const focus = (id) => {
-  return ParentIpc.invoke('ElectronBrowserViewFunctions.focus', id)
+const callFunction = (id, functionName) => {
+  return ParentIpc.invoke('ElectronWebContents.callFunction', id, functionName)
 }
 
-export const openDevtools = (id) => {
-  return ParentIpc.invoke('ElectronBrowserViewFunctions.openDevtools', id)
-}
+export const focus = ElectronWebContents.focus
 
-export const reload = (id) => {
-  return ParentIpc.invoke('ElectronBrowserViewFunctions.reload', id)
-}
+export const openDevtools = ElectronWebContents.openDevtools
 
-export const forward = (id) => {
-  return ParentIpc.invoke('ElectronBrowserViewFunctions.forward', id)
-}
+export const reload = ElectronWebContents.reload
 
-export const backward = (id) => {
-  return ParentIpc.invoke('ElectronBrowserViewFunctions.backward', id)
-}
+export const forward = ElectronWebContents.forward
+
+export const backward = ElectronWebContents.backward
 
 export const cancelNavigation = (id) => {
   return ParentIpc.invoke('ElectronBrowserViewFunctions.cancelNavigation', id)
@@ -40,9 +35,7 @@ export const hide = (id) => {
   return ParentIpc.invoke('ElectronBrowserViewFunctions.hide', id)
 }
 
-export const inspectElement = (id, x, y) => {
-  return ParentIpc.invoke('ElectronBrowserViewFunctions.inspectElement', id, x, y)
-}
+export const inspectElement = ElectronWebContents.inspectElement
 
 export const copyImageAt = (id, x, y) => {
   return ParentIpc.invoke('ElectronBrowserViewFunctions.copyImageAt', id, x, y)
@@ -53,5 +46,5 @@ export const setFallthroughKeyBindings = (fallthroughKeyBindings) => {
 }
 
 export const getStats = (id) => {
-  return ParentIpc.invoke('ElectronBrowserViewFunctions.getStats', id)
+  return ParentIpc.invoke('ElectronWebContents.getStats', id)
 }

package/src/parts/ElectronBrowserViewIpcState/ElectronBrowserViewIpcState.js

@@ -0,0 +1,19 @@
+const state = {
+  ipcMap: Object.create(null),
+}
+
+export const add = (id, ipc) => {
+  state.ipcMap[id] = ipc
+}
+
+export const get = (id) => {
+  return state.ipcMap[id]
+}
+
+export const remove = (id) => {
+  delete state.ipcMap[id]
+}
+
+export const getAll = () => {
+  return Object.values(state.ipcMap)
+}

package/src/parts/ElectronBrowserViewState/ElectronBrowserViewState.js

@@ -0,0 +1,15 @@
+const state = {
+  browserViews: Object.create(null),
+}
+
+export const add = (id) => {
+  state.browserViews[id] = id
+}
+
+export const remove = (id) => {
+  delete state.browserViews[id]
+}
+
+export const getAll = () => {
+  return Object.values(state.browserViews)
+}

package/src/parts/ElectronWebContents/ElectronWebContents.ipc.js

@@ -0,0 +1,14 @@
+import * as ElectronWebContents from './ElectronWebContents.js'
+
+export const name = 'ElectronWebContents'
+
+export const Commands = {
+  dispose: ElectronWebContents.dispose,
+  handleKeyBinding: ElectronWebContents.handleKeyBinding,
+  handleWindowOpen: ElectronWebContents.handleWindowOpen,
+  handleWillNavigate: ElectronWebContents.handleWillNavigate,
+  handleDidNavigate: ElectronWebContents.handleDidNavigate,
+  handleContextMenu: ElectronWebContents.handleContextMenu,
+  handleTitleUpdated: ElectronWebContents.handleTitleUpdated,
+  handleBrowserViewDestroyed: ElectronWebContents.handleBrowserViewDestroyed, // TODO rename to webcontents
+}

package/src/parts/ElectronWebContents/ElectronWebContents.js

@@ -0,0 +1,73 @@
+import * as ElectronBrowserViewIpcState from '../ElectronBrowserViewIpcState/ElectronBrowserViewIpcState.js'
+import * as ElectronBrowserViewState from '../ElectronBrowserViewState/ElectronBrowserViewState.js'
+import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+
+export const dispose = async (id) => {
+  await ParentIpc.invoke('ElectronWebContents.dispose', id)
+}
+
+export const callFunction = (webContentsId, method, ...params) => {
+  return ParentIpc.invoke(`ElectronWebContents.callFunction`, webContentsId, method, ...params)
+}
+
+export const focus = (webContentsId) => {
+  return callFunction(webContentsId, 'focus')
+}
+
+export const openDevtools = (webContentsId) => {
+  return callFunction(webContentsId, 'openDevTools')
+}
+
+export const reload = (webContentsId) => {
+  return callFunction(webContentsId, 'reload')
+}
+
+export const forward = (webContentsId) => {
+  return callFunction(webContentsId, 'goForward')
+}
+
+export const backward = (webContentsId) => {
+  return callFunction(webContentsId, 'goBack')
+}
+
+export const inspectElement = (webContentsId, x, y) => {
+  return callFunction(webContentsId, `inspectElement`, x, y)
+}
+
+export const handleWindowOpen = (webContentsId, url) => {
+  // TODO
+}
+
+const forwardEvent = (method, webContentsId, ...params) => {
+  const ipc = ElectronBrowserViewIpcState.get(webContentsId)
+  if (!ipc) {
+    console.log('no ipc', { webContentsId })
+    return
+  }
+  ipc.send({
+    jsonrpc: '2.0',
+    method: `SimpleBrowser.${method}`,
+    params,
+  })
+}
+
+export const handleWillNavigate = (...args) => {
+  return forwardEvent('handleWillNavigate', ...args)
+}
+
+export const handleDidNavigate = (...args) => {
+  return forwardEvent('handleDidNavigate', ...args)
+}
+
+export const handleContextMenu = (...args) => {
+  return forwardEvent('handleContextMenu', ...args)
+}
+
+export const handleTitleUpdated = (...args) => {
+  return forwardEvent('handleTitleUpdated', ...args)
+}
+
+export const handleBrowserViewDestroyed = (id) => {
+  ElectronBrowserViewState.remove(id)
+  ElectronBrowserViewIpcState.remove(id)
+}

package/src/parts/ElectronWindow/ElectronWindow.ipc.js

@@ -4,14 +4,15 @@ export const name = 'ElectronWindow'
 
 export const Commands = {
   close: ElectronWindow.close,
+  focus: ElectronWindow.focus,
+  getZoom: ElectronWindow.getZoom,
   maximize: ElectronWindow.maximize,
   minimize: ElectronWindow.minimize,
+  openNew: ElectronWindow.openNew,
   reload: ElectronWindow.reload,
   toggleDevtools: ElectronWindow.toggleDevtools,
   unmaximize: ElectronWindow.unmaximize,
   zoomIn: ElectronWindow.zoomIn,
   zoomOut: ElectronWindow.zoomOut,
   zoomReset: ElectronWindow.zoomReset,
-  openNew: ElectronWindow.openNew,
-  focus: ElectronWindow.focus,
 }

package/src/parts/ElectronWindow/ElectronWindow.js

@@ -92,6 +92,11 @@ export const zoomReset = (windowId) => {
   return setZoom(windowId, getDefaultZoomLevel(), getMinZoomLevel(), getMaxZoomLevel())
 }
 
+export const getZoom = (windowId) => {
+  // TODO zoom level should be stored in shared process
+  return ParentIpc.invoke('ElectronWindow.getZoom', windowId)
+}
+
 export const focus = (windowId) => {
   return ParentIpc.invoke('ElectronWindow.executeWebContentsFunction', windowId, 'focus')
 }
@@ -99,3 +104,7 @@ export const focus = (windowId) => {
 export const handleClose = (windowId) => {
   // TODO
 }
+
+export const getFocusedWindowId = () => {
+  return ParentIpc.invoke('ElectronWindow.getFocusedWindowId')
+}

package/src/parts/IpcChildWithElectronUtilityProcess/IpcChildWithElectronUtilityProcess.js

@@ -1,45 +1 @@
-import * as GetUtilityProcessPortData from '../GetUtilityProcessPortData/GetUtilityProcessPortData.js'
-
-export const listen = () => {
-  // @ts-ignore
-  const { parentPort } = process
-  if (!parentPort) {
-    throw new Error('parent port must be defined')
-  }
-  return parentPort
-}
-
-export const signal = (parentPort) => {
-  parentPort.postMessage('ready')
-}
-
-export const wrap = (parentPort) => {
-  return {
-    parentPort,
-    on(event, listener) {
-      if (event === 'message') {
-        const wrappedListener = (event) => {
-          const actualData = GetUtilityProcessPortData.getUtilityProcessPortData(event)
-          listener(actualData)
-        }
-        this.parentPort.on(event, wrappedListener)
-      } else if (event === 'close') {
-        this.parentPort.on('close', listener)
-      } else {
-        throw new Error('unsupported event type')
-      }
-    },
-    off(event, listener) {
-      this.parentPort.off(event, listener)
-    },
-    send(message) {
-      this.parentPort.postMessage(message)
-    },
-    sendAndTransfer(message, transfer) {
-      this.parentPort.postMessage(message, transfer)
-    },
-    dispose() {
-      this.parentPort.close()
-    },
-  }
-}
+export * from '@lvce-editor/ipc/dist/parts/IpcChildWithElectronUtilityProcess/IpcChildWithElectronUtilityProcess.js'

package/src/parts/IpcChildWithWebSocket/IpcChildWithWebSocket.js

@@ -1,59 +1 @@
-import * as GetFirstWebSocketEvent from '../GetFirstWebSocketEvent/GetFirstWebSocketEvent.js'
-import { IpcError } from '../IpcError/IpcError.js'
-import * as IsWebSocketOpen from '../IsWebSocketOpen/IsWebSocketOpen.js'
-import * as WebSocketSerialization from '../WebSocketSerialization/WebSocketSerialization.js'
-import * as WebSocketServer from '../WebSocketServer/WebSocketServer.js'
-
-export const listen = async ({ request, handle }) => {
-  if (!request) {
-    throw new IpcError('request must be defined')
-  }
-  if (!handle) {
-    throw new IpcError('handle must be defined')
-  }
-  const webSocket = await WebSocketServer.handleUpgrade(request, handle)
-  webSocket.pause()
-  if (!IsWebSocketOpen.isWebSocketOpen(webSocket)) {
-    const { type, event } = await GetFirstWebSocketEvent.getFirstWebSocketEvent(webSocket)
-  }
-  return webSocket
-}
-
-export const wrap = (webSocket) => {
-  return {
-    webSocket,
-    /**
-     * @type {any}
-     */
-    wrappedListener: undefined,
-    on(event, listener) {
-      switch (event) {
-        case 'message':
-          const wrappedListener = (message) => {
-            const data = WebSocketSerialization.deserialize(message)
-            listener(data)
-          }
-          webSocket.on('message', wrappedListener)
-          break
-        case 'close':
-          webSocket.on('close', listener)
-          break
-        default:
-          throw new Error('unknown event listener type')
-      }
-    },
-    off(event, listener) {
-      this.webSocket.off(event, listener)
-    },
-    send(message) {
-      const stringifiedMessage = WebSocketSerialization.serialize(message)
-      this.webSocket.send(stringifiedMessage)
-    },
-    dispose() {
-      this.webSocket.close()
-    },
-    start() {
-      this.webSocket.resume()
-    },
-  }
-}
+export * from '@lvce-editor/ipc/dist/parts/IpcChildWithWebSocket/IpcChildWithWebSocket.js'

package/src/parts/IpcParentWithNodeForkedProcess/IpcParentWithNodeForkedProcess.js

@@ -1,53 +1 @@
-import { fork } from 'node:child_process'
-import * as Assert from '../Assert/Assert.js'
-import { ChildProcessError } from '../ChildProcessError/ChildProcessError.js'
-import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
-import * as GetFirstNodeChildProcessEvent from '../GetFirstNodeChildProcessEvent/GetFirstNodeChildProcessEvent.js'
-import { VError } from '../VError/VError.js'
-
-export const create = async ({ path, argv = [], env, execArgv = [], stdio = 'inherit', name = 'child process' }) => {
-  try {
-    Assert.string(path)
-    const actualArgv = ['--ipc-type=node-forked-process', ...argv]
-    const childProcess = fork(path, actualArgv, {
-      env,
-      execArgv,
-      stdio: 'pipe',
-    })
-    const { type, event, stdout, stderr } = await GetFirstNodeChildProcessEvent.getFirstNodeChildProcessEvent(childProcess)
-    if (type === FirstNodeWorkerEventType.Exit) {
-      throw new ChildProcessError(stderr)
-    }
-    if (type === FirstNodeWorkerEventType.Error) {
-      throw new Error(`child process had an error ${event}`)
-    }
-    if (stdio === 'inherit' && childProcess.stdout && childProcess.stderr) {
-      childProcess.stdout.pipe(process.stdout)
-      childProcess.stderr.pipe(process.stderr)
-    }
-    return childProcess
-  } catch (error) {
-    throw new VError(error, `Failed to launch ${name}`)
-  }
-}
-
-export const wrap = (childProcess) => {
-  return {
-    childProcess,
-    on(event, listener) {
-      this.childProcess.on(event, listener)
-    },
-    off(event, listener) {
-      this.childProcess.off(event, listener)
-    },
-    send(message) {
-      this.childProcess.send(message)
-    },
-    sendAndTransfer(message, handle) {
-      this.childProcess.send(message, handle)
-    },
-    dispose() {
-      this.childProcess.kill()
-    },
-  }
-}
+export * from '@lvce-editor/ipc/dist/parts/IpcParentWithNodeForkedProcess/IpcParentWithNodeForkedProcess.js'

package/src/parts/Module/Module.js

@@ -140,6 +140,8 @@ export const load = (moduleId) => {
       return import('../HandleRemoteRequest/HandleRemoteRequest.ipc.js')
     case ModuleId.HandleMessagePortForExtensionHostHelperProcess:
       return import('../HandleMessagePortForExtensionHostHelperProcess/HandleMessagePortForExtensionHostHelperProcess.ipc.js')
+    case ModuleId.ElectronWebContents:
+      return import('../ElectronWebContents/ElectronWebContents.ipc.js')
     default:
       throw new Error(`module ${moduleId} not found`)
   }

package/src/parts/ModuleId/ModuleId.js

@@ -69,3 +69,4 @@ export const TemporaryMessagePort = 62
 export const GetElectronFileResponse = 63
 export const HandleRemoteRequest = 64
 export const HandleMessagePortForExtensionHostHelperProcess = 65
+export const ElectronWebContents = 66

package/src/parts/ModuleMap/ModuleMap.js

@@ -261,16 +261,17 @@ export const getModuleId = (commandId) => {
     case 'WebSocketServer.handleUpgrade':
       return ModuleId.WebSocketServer
     case 'ElectronWindow.close':
+    case 'ElectronWindow.focus':
+    case 'ElectronWindow.getZoom':
     case 'ElectronWindow.maximize':
     case 'ElectronWindow.minimize':
+    case 'ElectronWindow.openNew':
     case 'ElectronWindow.reload':
     case 'ElectronWindow.toggleDevtools':
     case 'ElectronWindow.unmaximize':
     case 'ElectronWindow.zoomIn':
     case 'ElectronWindow.zoomOut':
     case 'ElectronWindow.zoomReset':
-    case 'ElectronWindow.focus':
-    case 'ElectronWindow.openNew':
       return ModuleId.Window
     case 'Workspace.getHomeDir':
     case 'Workspace.resolveRoot':
@@ -295,6 +296,14 @@ export const getModuleId = (commandId) => {
       return ModuleId.HandleRemoteRequest
     case 'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess':
       return ModuleId.HandleMessagePortForExtensionHostHelperProcess
+    case 'ElectronWebContents.dispose':
+    case 'ElectronWebContents.handleKeyBinding':
+    case 'ElectronWebContents.handleWindowOpen':
+    case 'ElectronWebContents.handleWillNavigate':
+    case 'ElectronWebContents.handleDidNavigate':
+    case 'ElectronWebContents.handleContextMenu':
+    case 'ElectronWebContents.handlePageTitleUpdated':
+      return ModuleId.ElectronWebContents
     default:
       throw new CommandNotFoundError(commandId)
   }

package/src/parts/Platform/Platform.js

@@ -61,11 +61,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.22.7'
+export const version = '0.23.1'
 
-export const commit = '5861e23'
+export const commit = 'b40d3e9'
 
-export const date = '2024-01-28T15:06:28.000Z'
+export const date = '2024-02-11T08:32:28.000Z'
 
 export const getVersion = () => {
   return version

package/src/parts/RequiresSocket/RequiresSocket.js

@@ -11,6 +11,7 @@ const METHODS_THAT_REQUIRE_SOCKET = new Set([
   'ElectronApplicationMenu.setItems',
   'GetWindowId.getWindowId',
   'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess',
+  'ElectronBrowserView.createBrowserView',
 ])
 
 export const requiresSocket = (method) => {

package/src/parts/AppWindowStates/AppWindowStates.js

@@ -1,62 +0,0 @@
-export const state = {
-  /**
-   * @type {any[]}
-   */
-  windowStates: [],
-}
-
-export const findByWindowId = (windowId) => {
-  const { windowStates } = state
-  for (const windowState of windowStates) {
-    if (windowState.windowId === windowId) {
-      return windowState
-    }
-  }
-  return undefined
-}
-
-export const findByWebContentsId = (webContentsId) => {
-  const { windowStates } = state
-  for (const windowState of windowStates) {
-    if (windowState.webContentsId === webContentsId) {
-      return windowState
-    }
-  }
-  return undefined
-}
-
-export const findIndexById = (id) => {
-  const { windowStates } = state
-  for (let i = 0; i < windowStates.length; i++) {
-    const windowState = windowStates[i]
-    if (windowState.windowId === id) {
-      return i
-    }
-  }
-  return -1
-}
-
-export const remove = (windowId) => {
-  const index = findIndexById(windowId)
-  if (index === -1) {
-    throw new Error(`expected window ${windowId} to be in windows array`)
-  }
-  state.windowStates.splice(index, 1)
-}
-
-export const getAll = () => {
-  return state.windowStates
-}
-
-export const add = (config) => {
-  state.windowStates.push(config)
-}
-
-export const findByPort = (port) => {
-  for (const config of state.windowStates) {
-    if (config.port === port) {
-      return config
-    }
-  }
-  return undefined
-}

package/src/parts/ChildProcess/ChildProcessWithFork.js

@@ -1,19 +0,0 @@
-import { fork } from 'node:child_process'
-
-export const create = (path) => {
-  const childProcess = fork(path)
-  let _listener
-  return {
-    get onmessage() {
-      return _listener
-    },
-    set onmessage(listener) {
-      if (listener) {
-        childProcess.on('message', listener)
-      } else {
-        childProcess.off('message', listener)
-      }
-      _listener = listener
-    },
-  }
-}

package/src/parts/ChildProcessError/ChildProcessError.js

@@ -1,21 +0,0 @@
-import * as GetHelpfulChildProcessError from '../GetHelpfulChildProcessError/GetHelpfulChildProcessError.js'
-import * as JoinLines from '../JoinLines/JoinLines.js'
-import * as SplitLines from '../SplitLines/SplitLines.js'
-
-export class ChildProcessError extends Error {
-  constructor(stderr) {
-    const { message, code, stack } = GetHelpfulChildProcessError.getHelpfulChildProcessError('', stderr)
-    super(message || 'child process error')
-    this.name = 'ChildProcessError'
-    if (code) {
-      this.code = code
-    }
-    if (stack) {
-      const lines = SplitLines.splitLines(this.stack)
-      const [firstLine, ...stackLines] = lines
-      const newStackLines = [firstLine, ...stack, ...stackLines]
-      const newStack = JoinLines.joinLines(newStackLines)
-      this.stack = newStack
-    }
-  }
-}

package/src/parts/Configuration/Configuration.ipc.js

@@ -1,6 +0,0 @@
-import * as Configuration from './Configuration.js'
-
-export const Commands = {
-  '-1': Configuration.get,
-  '-2': Configuration.set,
-}

package/src/parts/Configuration/Configuration.js

@@ -1,36 +0,0 @@
-import * as Character from '../Character/Character.js'
-import { writeFile } from '../FileSystem/FileSystem.js'
-import * as JsonFile from '../JsonFile/JsonFile.js'
-
-let settings
-let settingsPromise
-
-const readSettings = async () => {
-  // TODO allow jsonc
-  if (!settings) {
-    if (!settingsPromise) {
-      settingsPromise = JsonFile.readJson('/tmp/settings.json')
-    }
-    await settingsPromise
-  }
-  return settings
-}
-
-const writeSettings = async () => {
-  // TODO jsonc
-  await writeFile('/tmp/settings.json', JSON.stringify(settings, null, 2) + Character.NewLine)
-}
-
-export const get = async (key) => {
-  await readSettings()
-  // TODO allow nested object get
-  return settings[key]
-}
-
-export const set = async (key, value) => {
-  await readSettings()
-  // TODO allow nested object set?
-  // how does vscode do it?
-  settings[key] = value
-  await writeSettings()
-}

package/src/parts/CreateCpuProfile/CreateCpuProfile.js

@@ -1,59 +0,0 @@
-import { writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import got from 'got'
-import { WebSocket } from 'ws'
-import * as DevtoolsProtocolRpc from '../DevtoolsProtocolRpc/DevtoolsProtocolRpc.js'
-
-const createConnection = (webSocketDebuggerUrl) => {
-  const webSocket = new WebSocket(webSocketDebuggerUrl)
-  // console.log({ webSocket })
-  return {
-    on(event, listener) {
-      if (event === 'message') {
-        const wrappedListener = (string) => {
-          listener(JSON.parse(string))
-        }
-        webSocket.on(event, wrappedListener)
-      } else {
-        webSocket.on(event, listener)
-      }
-    },
-    send(message) {
-      webSocket.send(JSON.stringify(message))
-    },
-  }
-}
-
-export const createCpuProfile = async (pid) => {
-  // AttachDebugger.attachDebugger(pid)
-  const response = await got('http://localhost:9229/json/list').json()
-  const first = response[0]
-  const { webSocketDebuggerUrl } = first
-  const ipc = createConnection(webSocketDebuggerUrl)
-
-  await new Promise((r) => {
-    ipc.on('open', r)
-  })
-  const rpc = DevtoolsProtocolRpc.create(ipc)
-  const result = await rpc.invoke('Debugger.enable')
-  const { debuggerId } = result.result
-  console.log({ debuggerId })
-  const p = await rpc.invoke('Profiler.enable')
-  await rpc.invoke('Profiler.start')
-  await new Promise((r) => {
-    setTimeout(r, 10000)
-  })
-  const profileResult = await rpc.invoke('Profiler.stop')
-  console.log({ profileResult })
-  const { profile } = profileResult.result
-  const profilePath = join(tmpdir(), 'node-profile.cpuprofile')
-  const profileString = JSON.stringify(profile)
-  await writeFile(profilePath, profileString)
-  console.log('finished')
-  // const value = await rpc.invoke('Runtime.evaluate', {
-  //   expression: '1+1',
-  // })
-  // await rpc.invoke('Debugger.pause')
-  // console.log({ value })
-}

package/src/parts/Credentials/Credentials.ipc.js

@@ -1,9 +0,0 @@
-import * as Credentials from './Credentials.js'
-
-export const Commands = {
-  deletePassword: Credentials.deletePassword,
-  findCredentials: Credentials.findCredentials,
-  findPassword: Credentials.findPassword,
-  getPassword: Credentials.getPassword,
-  setPassword: Credentials.setPassword,
-}

package/src/parts/Credentials/Credentials.js

@@ -1,61 +0,0 @@
-import keytar from 'keytar'
-import { VError } from '../VError/VError.js'
-
-/**
- * @param {string} service
- * @param {string} account
- */
-export const deletePassword = async (service, account) => {
-  try {
-    return await keytar.deletePassword(service, account)
-  } catch (error) {
-    throw new VError(error, `Failed to delete password from service ${service}`)
-  }
-}
-
-/**
- * @param {string} service
- */
-export const findCredentials = async (service) => {
-  try {
-    return keytar.findCredentials(service)
-  } catch (error) {
-    throw new VError(error, `Failed to find credentials from service ${service}`)
-  }
-}
-
-/**
- * @param {string} service
- */
-export const findPassword = async (service) => {
-  try {
-    return await keytar.findPassword(service)
-  } catch (error) {
-    throw new VError(error, `Failed to find password from service ${service}`)
-  }
-}
-
-/**
- * @param {string} service
- * @param {string} account
- */
-export const getPassword = async (service, account) => {
-  try {
-    return await keytar.getPassword(service, account)
-  } catch (error) {
-    throw new VError(error, `Failed to get password from service ${service}`)
-  }
-}
-
-/**
- * @param {string} service
- * @param {string} account
- * @param {string} password
- */
-export const setPassword = async (service, account, password) => {
-  try {
-    return await keytar.setPassword(service, account, password)
-  } catch (error) {
-    throw new VError(error, `Failed to set password for service ${service}`)
-  }
-}

package/src/parts/DevtoolsProtocolRpc/DevtoolsProtocolRpc.js

@@ -1,32 +0,0 @@
-const Id = {
-  id: 1,
-  create() {
-    return this.id++
-  },
-}
-
-export const create = (ipc) => {
-  const callbacks = Object.create(null)
-  const handleMessage = (message) => {
-    if ('result' in message) {
-      const callback = callbacks[message.id]
-      callback(message)
-      delete callbacks[message.id]
-    }
-  }
-  ipc.on('message', handleMessage)
-  return {
-    invoke(method, params = {}) {
-      const id = Id.create()
-      const promise = new Promise((resolve, reject) => {
-        callbacks[id] = resolve
-      })
-      ipc.send({
-        method,
-        id,
-        params,
-      })
-      return promise
-    },
-  }
-}

package/src/parts/ErrorType/ErrorType.js

@@ -1,4 +0,0 @@
-export const DomException = 'DOMException'
-export const ReferenceError = 'ReferenceError'
-export const SyntaxError = 'SyntaxError'
-export const TypeError = 'TypeError'

package/src/parts/ExtensionHostIpcWithWorker/ExtensionHostIpcWithWorker.js

@@ -1,34 +0,0 @@
-import { Worker } from 'node:worker_threads'
-import * as Platform from '../Platform/Platform.js'
-
-export const create = async () => {
-  const extensionHostPath = await Platform.getExtensionHostPath()
-  const child = new Worker(extensionHostPath, {
-    execArgv: ['--experimental-json-modules', '--max-old-space-size=60', '--enable-source-maps'],
-    env: {
-      ...process.env,
-      LOGS_DIR: Platform.getLogsDir(),
-      CONFIG_DIR: Platform.getConfigDir(),
-    },
-  })
-  return {
-    on(event, listener) {
-      switch (event) {
-        case 'message':
-          child.on('message', listener)
-          break
-        case 'error':
-          child.on('error', listener)
-          break
-        default:
-          break
-      }
-    },
-    send(message) {
-      child.postMessage(message)
-    },
-    dispose() {
-      child.terminate()
-    },
-  }
-}

package/src/parts/FirstWebSocketEventType/FirstWebSocketEventType.js

@@ -1,2 +0,0 @@
-export const Open = 1
-export const Close = 2

package/src/parts/GetActualPath/GetActualPath.js

@@ -1,8 +0,0 @@
-import { fileURLToPath } from 'node:url'
-
-export const getActualPath = (fileUri) => {
-  if (fileUri.startsWith('file://')) {
-    return fileURLToPath(fileUri)
-  }
-  return fileUri
-}

package/src/parts/GetErrorConstructor/GetErrorConstructor.js

@@ -1,28 +0,0 @@
-import * as ErrorType from '../ErrorType/ErrorType.js'
-
-export const getErrorConstructor = (message, type) => {
-  if (type) {
-    switch (type) {
-      case ErrorType.DomException:
-        return DOMException
-      case ErrorType.TypeError:
-        return TypeError
-      case ErrorType.SyntaxError:
-        return SyntaxError
-      case ErrorType.ReferenceError:
-        return ReferenceError
-      default:
-        return Error
-    }
-  }
-  if (message.startsWith('TypeError: ')) {
-    return TypeError
-  }
-  if (message.startsWith('SyntaxError: ')) {
-    return SyntaxError
-  }
-  if (message.startsWith('ReferenceError: ')) {
-    return ReferenceError
-  }
-  return Error
-}

package/src/parts/GetFirstNodeChildProcessEvent/GetFirstNodeChildProcessEvent.js

@@ -1,41 +0,0 @@
-import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
-
-export const getFirstNodeChildProcessEvent = async (childProcess) => {
-  const { type, event, stdout, stderr } = await new Promise((resolve, reject) => {
-    let stderr = ''
-    let stdout = ''
-    const cleanup = (value) => {
-      if (childProcess.stdout && childProcess.stderr) {
-        childProcess.stderr.off('data', handleStdErrData)
-        childProcess.stdout.off('data', handleStdoutData)
-      }
-      childProcess.off('message', handleMessage)
-      childProcess.off('exit', handleExit)
-      childProcess.off('error', handleError)
-      resolve(value)
-    }
-    const handleStdErrData = (data) => {
-      stderr += data
-    }
-    const handleStdoutData = (data) => {
-      stdout += data
-    }
-    const handleMessage = (event) => {
-      cleanup({ type: FirstNodeWorkerEventType.Message, event, stdout, stderr })
-    }
-    const handleExit = (event) => {
-      cleanup({ type: FirstNodeWorkerEventType.Exit, event, stdout, stderr })
-    }
-    const handleError = (event) => {
-      cleanup({ type: FirstNodeWorkerEventType.Error, event, stdout, stderr })
-    }
-    if (childProcess.stdout && childProcess.stderr) {
-      childProcess.stderr.on('data', handleStdErrData)
-      childProcess.stdout.on('data', handleStdoutData)
-    }
-    childProcess.on('message', handleMessage)
-    childProcess.on('exit', handleExit)
-    childProcess.on('error', handleError)
-  })
-  return { type, event, stdout, stderr }
-}

package/src/parts/GetFirstWebSocketEvent/GetFirstWebSocketEvent.js

@@ -1,25 +0,0 @@
-import * as FirstWebSocketEventType from '../FirstWebSocketEventType/FirstWebSocketEventType.js'
-import * as GetFirstEvent from '../GetFirstEvent/GetFirstEvent.js'
-import * as WebSocketReadyState from '../WebSocketReadyState/WebSocketReadyState.js'
-
-export const getFirstWebSocketEvent = async (webSocket) => {
-  switch (webSocket.readyState) {
-    case WebSocketReadyState.Open:
-      return {
-        type: FirstWebSocketEventType.Open,
-        event: undefined,
-      }
-    case WebSocketReadyState.Closed:
-      return {
-        type: FirstWebSocketEventType.Close,
-        event: undefined,
-      }
-    default:
-      break
-  }
-  const { type, event } = await GetFirstEvent.getFirstEvent(webSocket, {
-    open: FirstWebSocketEventType.Open,
-    close: FirstWebSocketEventType.Close,
-  })
-  return { type, event }
-}

package/src/parts/GetHelpfulChildProcessError/GetHelpfulChildProcessError.js

@@ -1,119 +0,0 @@
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-import * as SplitLines from '../SplitLines/SplitLines.js'
-import * as JoinLines from '../JoinLines/JoinLines.js'
-
-const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/
-const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/
-
-const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/
-const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/
-
-const RE_AT = /^\s+at/
-const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/
-
-const isUnhelpfulNativeModuleError = (stderr) => {
-  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr)
-}
-
-const isMessageCodeBlockStartIndex = (line) => {
-  return RE_MESSAGE_CODE_BLOCK_START.test(line)
-}
-
-const isMessageCodeBlockEndIndex = (line) => {
-  return RE_MESSAGE_CODE_BLOCK_END.test(line)
-}
-
-const getMessageCodeBlock = (stderr) => {
-  const lines = SplitLines.splitLines(stderr)
-  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex)
-  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex)
-  const relevantLines = lines.slice(startIndex, endIndex)
-  const relevantMessage = relevantLines.join(' ').slice('Error: '.length)
-  return relevantMessage
-}
-
-const getNativeModuleErrorMessage = (stderr) => {
-  const message = getMessageCodeBlock(stderr)
-  return {
-    message: `Incompatible native node module: ${message}`,
-    code: ErrorCodes.E_INCOMPATIBLE_NATIVE_MODULE,
-  }
-}
-
-const isModulesSyntaxError = (stderr) => {
-  if (!stderr) {
-    return false
-  }
-  return stderr.includes('SyntaxError: Cannot use import statement outside a module')
-}
-
-const getModuleSyntaxError = (stderr) => {
-  return {
-    message: `ES Modules are not supported in electron`,
-    code: ErrorCodes.E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
-  }
-}
-
-const isModuleNotFoundError = (stderr) => {
-  if (!stderr) {
-    return false
-  }
-  return stderr.includes('ERR_MODULE_NOT_FOUND')
-}
-
-const isModuleNotFoundMessage = (line) => {
-  return line.includes('ERR_MODULE_NOT_FOUND')
-}
-
-const getModuleNotFoundError = (stderr) => {
-  const lines = SplitLines.splitLines(stderr)
-  const messageIndex = lines.findIndex(isModuleNotFoundMessage)
-  const message = lines[messageIndex]
-  return {
-    message,
-    code: ErrorCodes.ERR_MODULE_NOT_FOUND,
-  }
-}
-
-const isNormalStackLine = (line) => {
-  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line)
-}
-
-const getDetails = (lines) => {
-  const index = lines.findIndex(isNormalStackLine)
-  if (index === -1) {
-    return {
-      actualMessage: JoinLines.joinLines(lines),
-      rest: [],
-    }
-  }
-  let lastIndex = index - 1
-  while (++lastIndex < lines.length) {
-    if (!isNormalStackLine(lines[lastIndex])) {
-      break
-    }
-  }
-  return {
-    actualMessage: lines[index - 1],
-    rest: lines.slice(index, lastIndex),
-  }
-}
-
-export const getHelpfulChildProcessError = (stdout, stderr) => {
-  if (isUnhelpfulNativeModuleError(stderr)) {
-    return getNativeModuleErrorMessage(stderr)
-  }
-  if (isModulesSyntaxError(stderr)) {
-    return getModuleSyntaxError(stderr)
-  }
-  if (isModuleNotFoundError(stderr)) {
-    return getModuleNotFoundError(stderr)
-  }
-  const lines = SplitLines.splitLines(stderr)
-  const { actualMessage, rest } = getDetails(lines)
-  return {
-    message: `${actualMessage}`,
-    code: '',
-    stack: rest,
-  }
-}

package/src/parts/GetUtilityProcessPortData/GetUtilityProcessPortData.js

@@ -1,10 +0,0 @@
-export const getUtilityProcessPortData = (event) => {
-  const { data, ports } = event
-  if (ports.length === 0) {
-    return data
-  }
-  return {
-    ...data,
-    params: [...ports, ...data.params],
-  }
-}

package/src/parts/Header/Header.js

@@ -1 +0,0 @@
-export const ContentType = 'Content-Type'

package/src/parts/IsSocket/IsSocket.js

@@ -1,5 +0,0 @@
-import { Socket } from 'node:net'
-
-export const isSocket = (value) => {
-  return value instanceof Socket
-}

package/src/parts/IsWebSocketOpen/IsWebSocketOpen.js

@@ -1,5 +0,0 @@
-import { WebSocket } from 'ws'
-
-export const isWebSocketOpen = (webSocket) => {
-  return webSocket.readyState === WebSocket.OPEN
-}

package/src/parts/JsonParsingError/JsonParsingError.js

@@ -1,19 +0,0 @@
-import * as JoinLines from '../JoinLines/JoinLines.js'
-import * as SplitLines from '../SplitLines/SplitLines.js'
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-
-export class JsonParsingError extends Error {
-  constructor(message, codeFrame, stack) {
-    super(message)
-    this.name = 'JsonParsingError'
-    this.code = ErrorCodes.E_JSON_PARSE
-    if (codeFrame) {
-      this.codeFrame = codeFrame
-    }
-
-    if (stack) {
-      const parentStack = JoinLines.joinLines(SplitLines.splitLines(this.stack).slice(1))
-      this.stack = this.name + ': ' + this.message + '\n' + stack + '\n' + parentStack
-    }
-  }
-}

package/src/parts/MergeStacks/MergeStacks.js

@@ -1,20 +0,0 @@
-import * as GetNewLineIndex from '../GetNewLineIndex/GetNewLineIndex.js'
-import * as NormalizeErrorLine from '../NormalizeErrorLine/NormalizeErrorLine.js'
-
-export const mergeStacks = (parent, child) => {
-  if (!child) {
-    return parent
-  }
-  const parentNewLineIndex = GetNewLineIndex.getNewLineIndex(parent)
-  const childNewLineIndex = GetNewLineIndex.getNewLineIndex(child)
-  if (childNewLineIndex === -1) {
-    return parent
-  }
-  const parentFirstLine = parent.slice(0, parentNewLineIndex)
-  const childRest = child.slice(childNewLineIndex)
-  const childFirstLine = NormalizeErrorLine.normalizeLine(child.slice(0, childNewLineIndex))
-  if (parentFirstLine.includes(childFirstLine)) {
-    return parentFirstLine + childRest
-  }
-  return child
-}

package/src/parts/NormalizeErrorLine/NormalizeErrorLine.js

@@ -1,9 +0,0 @@
-export const normalizeLine = (line) => {
-  if (line.startsWith('Error: ')) {
-    return line.slice(`Error: `.length)
-  }
-  if (line.startsWith('VError: ')) {
-    return line.slice(`VError: `.length)
-  }
-  return line
-}

package/src/parts/PassThroughElectronMessageForTerminalProcess/PassThroughElectronMessageForTerminalProcess.js

@@ -1,29 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as GetTerminalProcessPath from '../GetTerminalProcessPath/GetTerminalProcessPath.js'
-import * as IpcParent from '../IpcParent/IpcParent.js'
-import * as IpcParentType from '../IpcParentType/IpcParentType.js'
-
-/**
- *
- * @returns
- */
-export const handlePort = async (browserWindowPort, type, name) => {
-  Assert.object(browserWindowPort)
-  Assert.string(type)
-  Assert.string(name)
-  const ptyHostPath = GetTerminalProcessPath.getTerminalProcessPath()
-  const ipc = await IpcParent.create({
-    method: IpcParentType.ElectronUtilityProcess,
-    path: ptyHostPath,
-    name,
-  })
-  // TODO use connectIpc for better error handling
-  ipc.sendAndTransfer(
-    {
-      jsonrpc: '2.0',
-      method: 'HandleElectronMessagePort.handleElectronMessagePort',
-      params: [],
-    },
-    [browserWindowPort]
-  )
-}

package/src/parts/PassThroughElectronMessagePort/PassThroughElectronMessagePort.ipc.js

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

package/src/parts/PassThroughElectronMessagePort/PassThroughElectronMessagePort.js

@@ -1,4 +0,0 @@
-import * as Path from '../Path/Path.js'
-import * as Root from '../Root/Root.js'
-
-export const passThroughElectronMessagePort = () => {}

package/src/parts/PassThroughElectronMessagePortModule/PassThroughElectronMessagePortModule.js

@@ -1,8 +0,0 @@
-export const getModule = (type) => {
-  switch (type) {
-    case 'terminal-process':
-      return import('../PassThroughElectronMessageForTerminalProcess/PassThroughElectronMessageForTerminalProcess.js')
-    default:
-      return undefined
-  }
-}

package/src/parts/WebSocketReadyState/WebSocketReadyState.js

@@ -1,5 +0,0 @@
-import { WebSocket } from 'ws'
-
-export const Open = WebSocket.OPEN
-
-export const Closed = WebSocket.CLOSED

package/src/parts/WebSocketSerialization/WebSocketSerialization.js

@@ -1,7 +0,0 @@
-export const serialize = (message) => {
-  return JSON.stringify(message)
-}
-
-export const deserialize = (message) => {
-  return JSON.parse(message.toString())
-}