@lvce-editor/embeds-process 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Lvce Editor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# embeds-process

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@lvce-editor/embeds-process",
+  "version": "1.0.0",
+  "description": "",
+  "main": "src/embedsProcessMain.js",
+  "type": "module",
+  "directories": {
+    "test": "test"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "xo": {
+    "rules": {
+      "unicorn/filename-case": "off",
+      "indent": "off",
+      "semi": "off",
+      "no-unused-vars": "off",
+      "unicorn/numeric-separators-style": "off",
+      "no-extra-semi": "off",
+      "arrow-body-style": "off",
+      "padded-blocks": "off",
+      "capitalized-comments": "off",
+      "padding-line-between-statements": "off",
+      "arrow-parens": "off",
+      "no-warning-comments": "off",
+      "array-bracket-spacing": "off",
+      "comma-spacing": "off",
+      "unicorn/no-array-callback-reference": "off",
+      "comma-dangle": "off",
+      "operator-linebreak": "off",
+      "no-case-declarations": "off",
+      "no-undef": "off",
+      "object-curly-spacing": "off",
+      "object-shorthand": "off",
+      "complexity": "off",
+      "no-labels": "off",
+      "no-multi-assign": "off",
+      "max-params": "off",
+      "no-bitwise": "off",
+      "unicorn/prefer-math-trunc": "off",
+      "no-await-in-loop": "off",
+      "unicorn/prefer-add-event-listener": "off",
+      "no-unused-expressions": "off",
+      "unicorn/better-regex": "off",
+      "unicorn/no-array-push-push": "off",
+      "unicorn/prevent-abbreviations": "off"
+    },
+    "ignores": [
+      "distmin"
+    ]
+  },
+  "dependencies": {
+    "@lvce-editor/ipc": "^8.2.1",
+    "@lvce-editor/json-rpc": "^1.3.0"
+  }
+}

package/src/embedsProcessMain.js

@@ -0,0 +1,3 @@
+import * as Main from './parts/Main/Main.js'
+
+Main.main()

package/src/parts/ApplyIncomingIpcResponse/ApplyIncomingIpcResponse.js

@@ -0,0 +1,11 @@
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+
+export const applyIncomingIpcResponse = async (target, response, ipcId) => {
+  switch (response.type) {
+    case 'handle':
+      HandleIpc.handleIpc(target)
+      break
+    default:
+      throw new Error('unexpected response')
+  }
+}

package/src/parts/Assert/Assert.js

@@ -0,0 +1,94 @@
+// TODO treeshake out this whole module in production
+
+import { AssertionError } from '../AssertionError/AssertionError.js'
+
+const getType = (value) => {
+  switch (typeof value) {
+    case 'number':
+      return 'number'
+    case 'function':
+      return 'function'
+    case 'string':
+      return 'string'
+    case 'object':
+      if (value === null) {
+        return 'null'
+      }
+      if (Array.isArray(value)) {
+        return 'array'
+      }
+      if (value instanceof Uint32Array) {
+        return 'uint32array'
+      }
+      return 'object'
+    case 'boolean':
+      return 'boolean'
+    default:
+      return 'unknown'
+  }
+}
+
+export const object = (value) => {
+  const type = getType(value)
+  if (type !== 'object') {
+    throw new AssertionError('expected value to be of type object')
+  }
+}
+
+export const number = (value) => {
+  const type = getType(value)
+  if (type !== 'number') {
+    throw new AssertionError('expected value to be of type number')
+  }
+  if (isNaN(value)) {
+    throw new AssertionError('value is NaN')
+  }
+}
+
+export const array = (value) => {
+  const type = getType(value)
+  if (type !== 'array') {
+    throw new AssertionError('expected value to be of type array')
+  }
+}
+
+export const string = (value) => {
+  const type = getType(value)
+  if (type !== 'string') {
+    throw new AssertionError('expected value to be of type string')
+  }
+}
+
+export const null_ = (value) => {
+  const type = getType(value)
+  if (type !== 'null') {
+    throw new AssertionError('expected value to be of type null')
+  }
+}
+
+export const boolean = (value) => {
+  const type = getType(value)
+  if (type !== 'boolean') {
+    throw new AssertionError('expected value to be of type boolean')
+  }
+}
+
+export const fn = (value) => {
+  const type = getType(value)
+  if (type !== 'function') {
+    throw new AssertionError('expected value to be of type function')
+  }
+}
+
+export const uint32array = (value) => {
+  const type = getType(value)
+  if (type !== 'uint32array') {
+    throw new AssertionError('expected value to be of type uint32array')
+  }
+}
+
+export const greaterZero = (value) => {
+  if (value <= 0) {
+    throw new Error('value must be greater than zero')
+  }
+}

package/src/parts/AssertionError/AssertionError.js

@@ -0,0 +1,6 @@
+export class AssertionError extends Error {
+  constructor(message) {
+    super(message)
+    this.name = 'AssertionError'
+  }
+}

package/src/parts/Callback/Callback.js

@@ -0,0 +1 @@
+export { resolve } from '@lvce-editor/json-rpc'

package/src/parts/Command/Command.js

@@ -0,0 +1,9 @@
+import * as CommandState from '../CommandState/CommandState.js'
+
+export const execute = (command, ...args) => {
+  const fn = CommandState.getCommand(command)
+  if (!fn) {
+    throw new Error(`Command not found ${command}`)
+  }
+  return fn(...args)
+}

package/src/parts/CommandMap/CommandMap.js

@@ -0,0 +1,24 @@
+import * as HandleElectronMessagePort from '../HandleElectronMessagePort/HandleElectronMessagePort.js'
+import * as ElectronWebContentsView from '../ElectronWebContentsView/ElectronWebContentsView.js'
+import * as ElectronWebContents from '../ElectronWebContents/ElectronWebContents.js'
+
+export const commandMap = {
+  'ElectronWebContentsView.backward': ElectronWebContents.backward,
+  'ElectronWebContentsView.createWebContentsView': ElectronWebContentsView.createWebContentsView,
+  'ElectronWebContentsView.disposeWebContentsView': ElectronWebContentsView.disposeWebContentsView,
+  'ElectronWebContentsView.focus': ElectronWebContents.focus,
+  'ElectronWebContentsView.forward': ElectronWebContents.forward,
+  'ElectronWebContentsView.getStats': ElectronWebContentsView.getStats,
+  'ElectronWebContentsView.inspectElement': ElectronWebContents.inspectElement,
+  'ElectronWebContentsView.openDevtools': ElectronWebContents.openDevtools,
+  'ElectronWebContentsView.reload': ElectronWebContents.reload,
+  'ElectronWebContentsView.resizeBrowserView': ElectronWebContentsView.resizeWebContentsView,
+  'ElectronWebContentsView.setIframeSrc': ElectronWebContentsView.setIframeSrc,
+  'ElectronWebContentsView.show': ElectronWebContentsView.show,
+  'ElectronWebContents.handleDidNavigate': ElectronWebContentsView.handleDidNavigate,
+  'ElectronWebContents.handleTitleUpdated': ElectronWebContentsView.handleTitleUpdated,
+  'ElectronWebContents.handleBrowserViewDestroyed': ElectronWebContentsView.handleBrowserViewDestroyed,
+  'ElectronWebContents.handleWillNavigate': ElectronWebContentsView.handleWillNavigate,
+  'ElectronWebContents.handleContextMenu': ElectronWebContentsView.handleContextMenu,
+  'HandleElectronMessagePort.handleElectronMessagePort': HandleElectronMessagePort.handleElectronMessagePort,
+}

package/src/parts/CommandState/CommandState.js

@@ -0,0 +1,17 @@
+export const state = {
+  commands: Object.create(null),
+}
+
+export const registerCommand = (key, fn) => {
+  state.commands[key] = fn
+}
+
+export const registerCommands = (commandMap) => {
+  for (const [key, value] of Object.entries(commandMap)) {
+    registerCommand(key, value)
+  }
+}
+
+export const getCommand = (key) => {
+  return state.commands[key]
+}

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.js

@@ -0,0 +1,77 @@
+import * as ElectronBrowserViewIpcState from '../ElectronWebContentsViewIpcState/ElectronWebContentsViewIpcState.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(`[shared-process] no ipc for webcontents ${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 handleKeyBinding = (...args) => {
+  forwardEvent('handleKeyBinding', ...args)
+}
+
+export const handleBrowserViewDestroyed = (id) => {
+  ElectronBrowserViewState.remove(id)
+  ElectronBrowserViewIpcState.remove(id)
+}

package/src/parts/ElectronWebContentsView/ElectronWebContentsView.js

@@ -0,0 +1,58 @@
+import * as Assert from '../Assert/Assert.js'
+import * as ElectronWebContents from '../ElectronWebContents/ElectronWebContents.js'
+import * as ElectronWebContentsViewIpcState from '../ElectronWebContentsViewIpcState/ElectronWebContentsViewIpcState.js'
+import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
+export const createWebContentsView = async (ipc, restoreId, fallthroughKeyBindings) => {
+  Assert.number(restoreId)
+  const webContentsId = await ParentIpc.invoke('ElectronWebContentsView.createWebContentsView', restoreId)
+  ElectronWebContentsViewIpcState.add(webContentsId, ipc)
+  // TODO get window id from renderer worker
+  await ParentIpc.invoke('ElectronWebContentsView.attachEventListeners', webContentsId)
+  await ParentIpc.invoke('ElectronWebContentsViewFunctions.setBackgroundColor', webContentsId, 'white')
+  return webContentsId
+}
+
+export const disposeWebContentsView = async (id) => {
+  await ParentIpc.invoke('ElectronWebContentsView.disposeWebContentsView', id)
+  await ElectronWebContents.dispose(id)
+}
+
+export const resizeWebContentsView = async (id, ...args) => {
+  return ParentIpc.invoke('ElectronWebContentsViewFunctions.resizeBrowserView', id, ...args)
+}
+
+export const setIframeSrc = async (id, ...args) => {
+  return ParentIpc.invoke('ElectronWebContentsViewFunctions.setIframeSrc', id, ...args)
+}
+
+export const getStats = async (id, ...args) => {
+  return ParentIpc.invoke('ElectronWebContentsViewFunctions.getStats', id, ...args)
+}
+
+export const show = async (id, ...args) => {
+  return ParentIpc.invoke('ElectronWebContentsViewFunctions.show', id, ...args)
+}
+
+const forwardIpcEvent =
+  (key) =>
+  (id, ...args) => {
+    const ipc = ElectronWebContentsViewIpcState.get(id)
+    if (!ipc) {
+      return
+    }
+    JsonRpc.send(ipc, key, id, ...args)
+  }
+
+export const handleDidNavigate = forwardIpcEvent('ElectronWebContentsView.handleDidNavigate')
+
+export const handleTitleUpdated = forwardIpcEvent('ElectronWebContentsView.handleTitleUpdated')
+
+export const handleWillNavigate = forwardIpcEvent('ElectronWebContentsView.handleWillNavigate')
+
+export const handleContextMenu = forwardIpcEvent('ElectronWebContentsView.handleContextMenu')
+
+export const handleBrowserViewDestroyed = (id, ...args) => {
+  // TODO send to embeds worker?
+}

package/src/parts/ElectronWebContentsViewIpcState/ElectronWebContentsViewIpcState.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.entries(state.ipcMap)
+}

package/src/parts/HandleElectronMessagePort/HandleElectronMessagePort.js

@@ -0,0 +1,20 @@
+import * as Assert from '../Assert/Assert.js'
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js'
+
+export const handleElectronMessagePort = async (messagePort, ipcId) => {
+  Assert.object(messagePort)
+  Assert.number(ipcId)
+  return HandleIncomingIpc.handleIncomingIpc(ipcId, messagePort, {})
+  // const ipc = await IpcChild.listen({
+  //   method: IpcChildType.ElectronMessagePort,
+  //   messagePort,
+  // })
+  // HandleIpc.handleIpc(ipc)
+  // if (ipcId === IpcId.MainProcess) {
+  //   ParentIpc.state.ipc = ipc
+  // } else if (ipcId === IpcId.SharedProcess) {
+  //   SharedProcessIpc.state.ipc = ipc
+  // } else if (ipcId === IpcId.EmbedsWorker) {
+  //   ipc.addEventListener('close', HandleIpcClosed.handleIpcClosed)
+  // }
+}

package/src/parts/HandleIncomingIpc/HandleIncomingIpc.js

@@ -0,0 +1,15 @@
+import * as ApplyIncomingIpcResponse from '../ApplyIncomingIpcResponse/ApplyIncomingIpcResponse.js'
+import * as Assert from '../Assert/Assert.js'
+import * as HandleIncomingIpcMessagePort from '../HandleIncomingIpcMessagePort/HandleIncomingIpcMessagePort.js'
+import * as HandleIpcModule from '../HandleIpcModule/HandleIpcModule.js'
+
+const getIpcAndResponse = (module, handle, message) => {
+  return HandleIncomingIpcMessagePort.handleIncomingIpcMessagePort(module, handle, message)
+}
+
+export const handleIncomingIpc = async (ipcId, handle, message) => {
+  Assert.number(ipcId)
+  const module = HandleIpcModule.getModule(ipcId)
+  const { target, response } = await getIpcAndResponse(module, handle, message)
+  await ApplyIncomingIpcResponse.applyIncomingIpcResponse(target, response, ipcId)
+}

package/src/parts/HandleIncomingIpcMessagePort/HandleIncomingIpcMessagePort.js

@@ -0,0 +1,8 @@
+export const handleIncomingIpcMessagePort = async (module, handle, message) => {
+  const target = await module.targetMessagePort(handle, message)
+  const response = module.upgradeMessagePort(handle, message)
+  return {
+    target,
+    response,
+  }
+}

package/src/parts/HandleIpc/HandleIpc.js

@@ -0,0 +1,5 @@
+import * as HandleMessage from '../HandleMessage/HandleMessage.js'
+
+export const handleIpc = (ipc) => {
+  ipc.addEventListener('message', HandleMessage.handleMessage)
+}

package/src/parts/HandleIpcClosed/HandleIpcClosed.js

@@ -0,0 +1,23 @@
+import * as ElectronWebContentsView from '../ElectronWebContentsView/ElectronWebContentsView.js'
+import * as ElectronWebContentsViewIpcState from '../ElectronWebContentsViewIpcState/ElectronWebContentsViewIpcState.js'
+
+const getIdsToDispose = (ipc) => {
+  const entries = ElectronWebContentsViewIpcState.getAll()
+  const toDispose = []
+
+  for (const [id, value] of entries) {
+    if (value === ipc) {
+      toDispose.push(parseInt(id))
+    }
+  }
+  return toDispose
+}
+
+export const handleIpcClosed = async (event) => {
+  const idsToDispose = getIdsToDispose(event.target)
+  for (const id of idsToDispose) {
+    ElectronWebContentsViewIpcState.remove(id)
+    await ElectronWebContentsView.disposeWebContentsView(id)
+  }
+  // SharedProcessIpc.send('HandleMessagePortForEmbedsProcess.handleEmbedsProcessIpcClosed')
+}

package/src/parts/HandleIpcEmbedsWorker/HandleIpcEmbedsWorker.js

@@ -0,0 +1,20 @@
+import * as Assert from '../Assert/Assert.js'
+import * as HandleIpcClosed from '../HandleIpcClosed/HandleIpcClosed.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+export const targetMessagePort = async (messagePort, message) => {
+  Assert.object(messagePort)
+  const ipc = await IpcChild.listen({
+    method: IpcChildType.ElectronMessagePort,
+    messagePort,
+  })
+  ipc.addEventListener('close', HandleIpcClosed.handleIpcClosed)
+  return ipc
+}
+
+export const upgradeMessagePort = () => {
+  return {
+    type: 'handle',
+  }
+}

package/src/parts/HandleIpcMainProcess/HandleIpcMainProcess.js

@@ -0,0 +1,20 @@
+import * as Assert from '../Assert/Assert.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+
+export const targetMessagePort = async (messagePort, message) => {
+  Assert.object(messagePort)
+  const ipc = await IpcChild.listen({
+    method: IpcChildType.ElectronMessagePort,
+    messagePort,
+  })
+  ParentIpc.state.ipc = ipc
+  return ipc
+}
+
+export const upgradeMessagePort = () => {
+  return {
+    type: 'handle',
+  }
+}

package/src/parts/HandleIpcModule/HandleIpcModule.js

@@ -0,0 +1,19 @@
+import * as Assert from '../Assert/Assert.js'
+import * as HandleIpcEmbedsWorker from '../HandleIpcEmbedsWorker/HandleIpcEmbedsWorker.js'
+import * as HandleIpcMainProcess from '../HandleIpcMainProcess/HandleIpcMainProcess.js'
+import * as HandleIpcSharedProcess from '../HandleIpcSharedProcess/HandleIpcSharedProcess.js'
+import * as IpcId from '../IpcId/IpcId.js'
+
+export const getModule = (ipcId) => {
+  Assert.number(ipcId)
+  switch (ipcId) {
+    case IpcId.SharedProcess:
+      return HandleIpcSharedProcess
+    case IpcId.EmbedsWorker:
+      return HandleIpcEmbedsWorker
+    case IpcId.MainProcess:
+      return HandleIpcMainProcess
+    default:
+      throw new Error(`unexpected incoming ipc`)
+  }
+}

package/src/parts/HandleIpcSharedProcess/HandleIpcSharedProcess.js

@@ -0,0 +1,20 @@
+import * as Assert from '../Assert/Assert.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+import * as SharedProcessIpc from '../SharedProcessIpc/SharedProcessIpc.js'
+
+export const targetMessagePort = async (messagePort, message) => {
+  Assert.object(messagePort)
+  const ipc = await IpcChild.listen({
+    method: IpcChildType.ElectronMessagePort,
+    messagePort,
+  })
+  SharedProcessIpc.state.ipc = ipc
+  return ipc
+}
+
+export const upgradeMessagePort = () => {
+  return {
+    type: 'handle',
+  }
+}

package/src/parts/HandleMessage/HandleMessage.js

@@ -0,0 +1,19 @@
+import * as Callback from '../Callback/Callback.js'
+import * as Command from '../Command/Command.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
+const prepare = (error) => {
+  return error
+}
+
+const requiresSocket = (method) => {
+  return false
+}
+
+const logError = (error, prettyError) => {
+  console.error(error)
+}
+
+export const handleMessage = (event) => {
+  return JsonRpc.handleJsonRpcMessage(event.target, event.data, Command.execute, Callback.resolve, prepare, logError, requiresSocket)
+}

package/src/parts/IpcChild/IpcChild.js

@@ -0,0 +1,15 @@
+import * as IpcChildModule from '../IpcChildModule/IpcChildModule.js'
+
+export const listen = async ({ method, ...params }) => {
+  const module = await IpcChildModule.getModule(method)
+  // @ts-ignore
+  const rawIpc = await module.listen(params)
+  // @ts-ignore
+  if (module.signal) {
+    // @ts-ignore
+    module.signal(rawIpc)
+  }
+  // @ts-ignore
+  const ipc = module.wrap(rawIpc)
+  return ipc
+}

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -0,0 +1,25 @@
+import {
+  IpcChildWithElectronMessagePort,
+  IpcChildWithElectronUtilityProcess,
+  IpcChildWithNodeForkedProcess,
+  IpcChildWithNodeWorker,
+  IpcChildWithWebSocket,
+} from '@lvce-editor/ipc'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+export const getModule = (method) => {
+  switch (method) {
+    case IpcChildType.NodeForkedProcess:
+      return IpcChildWithNodeForkedProcess
+    case IpcChildType.NodeWorker:
+      return IpcChildWithNodeWorker
+    case IpcChildType.ElectronUtilityProcess:
+      return IpcChildWithElectronUtilityProcess
+    case IpcChildType.ElectronMessagePort:
+      return IpcChildWithElectronMessagePort
+    case IpcChildType.WebSocket:
+      return IpcChildWithWebSocket
+    default:
+      throw new Error('unexpected ipc type')
+  }
+}

package/src/parts/IpcChildType/IpcChildType.js

@@ -0,0 +1,20 @@
+export const NodeWorker = 1
+export const NodeForkedProcess = 2
+export const ElectronUtilityProcess = 3
+export const ElectronMessagePort = 4
+export const NodeMessagePort = 5
+export const WebSocket = 6
+
+export const Auto = () => {
+  const { argv } = process
+  if (argv.includes('--ipc-type=node-worker')) {
+    return NodeWorker
+  }
+  if (argv.includes('--ipc-type=node-forked-process')) {
+    return NodeForkedProcess
+  }
+  if (argv.includes('--ipc-type=electron-utility-process')) {
+    return ElectronUtilityProcess
+  }
+  throw new Error(`[shared-process] unknown ipc type`)
+}

package/src/parts/IpcId/IpcId.js

@@ -0,0 +1,9 @@
+export const EmbedsProcess = 2
+export const EmbedsWorker = 77
+export const ExtensionHostHelperProcess = 3
+export const MainProcess = -5
+export const ProcessExplorer = 11
+export const SearchProcess = 13
+export const SharedProcess = 1
+export const TerminalProcess = 7
+export const Unknown = 0

package/src/parts/JsonRpc/JsonRpc.js

@@ -0,0 +1 @@
+export * from '@lvce-editor/json-rpc'

package/src/parts/Listen/Listen.js

@@ -0,0 +1,10 @@
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+import * as ParentIpc from '../ParentIpc/ParentIpc.js'
+
+export const listen = async () => {
+  const ipc = await IpcChild.listen({ method: IpcChildType.Auto() })
+  HandleIpc.handleIpc(ipc)
+  ParentIpc.state.ipc = ipc
+}

package/src/parts/Main/Main.js

@@ -0,0 +1,8 @@
+import * as CommandMap from '../CommandMap/CommandMap.js'
+import * as CommandState from '../CommandState/CommandState.js'
+import * as Listen from '../Listen/Listen.js'
+
+export const main = async () => {
+  CommandState.registerCommands(CommandMap.commandMap)
+  await Listen.listen()
+}

package/src/parts/MainProcessIpc/MainProcessIpc.js

@@ -0,0 +1,20 @@
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
+export const state = {
+  /**
+   * @type {any}
+   */
+  ipc: undefined,
+}
+
+export const invoke = (method, ...params) => {
+  return JsonRpc.invoke(state.ipc, method, ...params)
+}
+
+export const send = (method, ...params) => {
+  return JsonRpc.send(state.ipc, method, ...params)
+}
+
+export const invokeAndTransfer = (method, transfer, ...params) => {
+  return JsonRpc.invokeAndTransfer(state.ipc, transfer, method, ...params)
+}

package/src/parts/ParentIpc/ParentIpc.js

@@ -0,0 +1,20 @@
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
+export const state = {
+  /**
+   * @type {any}
+   */
+  ipc: undefined,
+}
+
+export const invoke = (method, ...params) => {
+  return JsonRpc.invoke(state.ipc, method, ...params)
+}
+
+export const send = (method, ...params) => {
+  return JsonRpc.send(state.ipc, method, ...params)
+}
+
+export const invokeAndTransfer = (method, transfer, ...params) => {
+  return JsonRpc.invokeAndTransfer(state.ipc, transfer, method, ...params)
+}

package/src/parts/SharedProcessIpc/SharedProcessIpc.js

@@ -0,0 +1,20 @@
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
+export const state = {
+  /**
+   * @type {any}
+   */
+  ipc: undefined,
+}
+
+export const invoke = (method, ...params) => {
+  return JsonRpc.invoke(state.ipc, method, ...params)
+}
+
+export const send = (method, ...params) => {
+  return JsonRpc.send(state.ipc, method, ...params)
+}
+
+export const invokeAndTransfer = (method, transfer, ...params) => {
+  return JsonRpc.invokeAndTransfer(state.ipc, transfer, method, ...params)
+}