@lvce-editor/shared-process 0.25.7 → 0.25.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.25.7",
+  "version": "0.25.9",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -18,12 +18,12 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "^1.2.0",
-    "@lvce-editor/extension-host-helper-process": "0.25.7",
-    "@lvce-editor/ipc": "^3.4.0",
+    "@lvce-editor/extension-host-helper-process": "0.25.9",
+    "@lvce-editor/ipc": "^3.6.0",
     "@lvce-editor/json-rpc": "^1.3.0",
     "@lvce-editor/jsonc-parser": "^1.2.0",
     "@lvce-editor/pretty-error": "^1.5.0",
-    "@lvce-editor/pty-host": "0.25.7",
+    "@lvce-editor/pty-host": "0.25.9",
     "@lvce-editor/verror": "^1.2.0",
     "@lvce-editor/web-socket-server": "^1.1.0",
     "debug": "^4.3.4",

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -1,16 +1,22 @@
+import {
+  IpcChildWithElectronMessagePort,
+  IpcChildWithElectronUtilityProcess,
+  IpcChildWithNodeForkedProcess,
+  IpcChildWithNodeWorker,
+  IpcChildWithWebSocket,
+} from '@lvce-editor/ipc'
 import * as IpcChildType from '../IpcChildType/IpcChildType.js'
-import { IpcChildWithElectronUtilityProcess, IpcChildWithWebSocket } from '@lvce-editor/ipc'
 
 export const getModule = (method) => {
   switch (method) {
     case IpcChildType.NodeForkedProcess:
-      return import('../IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js')
+      return IpcChildWithNodeForkedProcess
     case IpcChildType.NodeWorker:
-      return import('../IpcChildWithNodeWorker/IpcChildWithNodeWorker.js')
+      return IpcChildWithNodeWorker
     case IpcChildType.ElectronUtilityProcess:
       return IpcChildWithElectronUtilityProcess
     case IpcChildType.ElectronMessagePort:
-      return import('../IpcChildWithElectronMessagePort/IpcChildWithElectronMessagePort.js')
+      return IpcChildWithElectronMessagePort
     case IpcChildType.NodeMessagePort:
       return import('../IpcChildWithNodeMessagePort/IpcChildWithNodeMessagePort.js')
     case IpcChildType.WebSocket:

package/src/parts/IpcParentModule/IpcParentModule.js

@@ -1,11 +1,12 @@
+import { IpcParentWithNodeForkedProcess, IpcParentWithNodeWorker } from '@lvce-editor/ipc'
 import * as IpcParentType from '../IpcParentType/IpcParentType.js'
 
 export const getModule = (method) => {
   switch (method) {
     case IpcParentType.NodeWorker:
-      return import('../IpcParentWithNodeWorker/IpcParentWithNodeWorker.js')
+      return IpcParentWithNodeWorker
     case IpcParentType.NodeForkedProcess:
-      return import('../IpcParentWithNodeForkedProcess/IpcParentWithNodeForkedProcess.js')
+      return IpcParentWithNodeForkedProcess
     case IpcParentType.ElectronUtilityProcess:
       return import('../IpcParentWithElectronUtilityProcess/IpcParentWithElectronUtilityProcess.js')
     default:

package/src/parts/Platform/Platform.js

@@ -61,11 +61,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.25.7'
+export const version = '0.25.9'
 
-export const commit = '95efa27'
+export const commit = '5d646c0'
 
-export const date = '2024-04-10T20:20:35.000Z'
+export const date = '2024-04-13T13:55:08.000Z'
 
 export const getVersion = () => {
   return version

package/src/parts/IpcChildWithNodeForkedProcess/IpcChildWithNodeForkedProcess.js

@@ -1,46 +0,0 @@
-export const listen = async () => {
-  if (!process.send) {
-    throw new Error('process.send must be defined')
-  }
-  return process
-}
-
-export const signal = (process) => {
-  process.send('ready')
-}
-
-const getActualData = (message, handle) => {
-  if (handle) {
-    return {
-      ...message,
-      params: [...message.params, handle],
-    }
-  }
-  return message
-}
-
-export const wrap = (process) => {
-  return {
-    process,
-    on(event, listener) {
-      if (event === 'message') {
-        const wrappedListener = (event, handle) => {
-          const actualData = getActualData(event, handle)
-          listener(actualData)
-        }
-        this.process.on(event, wrappedListener)
-      } else if (event === 'close') {
-        this.process.on('close', listener)
-      } else {
-        throw new Error('unsupported event type')
-      }
-    },
-    off(event, listener) {
-      this.process.off(event, listener)
-    },
-    send(message) {
-      this.process.send(message)
-    },
-    dispose() {},
-  }
-}

package/src/parts/IpcChildWithNodeWorker/IpcChildWithNodeWorker.js

@@ -1,45 +0,0 @@
-import { parentPort } from 'node:worker_threads'
-import * as IsElectron from '../IsElectron/IsElectron.js'
-
-export const listen = async () => {
-  if (!parentPort) {
-    throw new Error('parentPort is required')
-  }
-  return parentPort
-}
-
-export const signal = (parentPort) => {
-  parentPort.postMessage('ready')
-}
-
-const getActualData = (message) => {
-  return message
-}
-
-export const wrap = (parentPort) => {
-  return {
-    parentPort,
-    on(event, listener) {
-      if (event === 'message') {
-        const wrappedListener = (event) => {
-          const actualData = getActualData(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)
-    },
-    dispose() {
-      this.parentPort.close()
-    },
-  }
-}

package/src/parts/IpcParentWithNodeForkedProcess/IpcParentWithNodeForkedProcess.js

@@ -1,5 +0,0 @@
-import { IpcParentWithNodeForkedProcess } from '@lvce-editor/ipc'
-
-export const create = IpcParentWithNodeForkedProcess.create
-
-export const wrap = IpcParentWithNodeForkedProcess.wrap

package/src/parts/IpcParentWithNodeWorker/IpcParentWithNodeWorker.js

@@ -1,36 +0,0 @@
-import { Worker } from 'node:worker_threads'
-import * as Assert from '../Assert/Assert.js'
-import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
-import * as GetFirstNodeWorkerEvent from '../GetFirstNodeWorkerEvent/GetFirstNodeWorkerEvent.js'
-
-export const create = async ({ path, argv, env, execArgv }) => {
-  Assert.string(path)
-  const worker = new Worker(path, {
-    argv,
-    env,
-    execArgv,
-  })
-  const { type, event } = await GetFirstNodeWorkerEvent.getFirstNodeWorkerEvent(worker)
-  if (type === FirstNodeWorkerEventType.Error) {
-    throw event
-  }
-  return worker
-}
-
-export const wrap = (worker) => {
-  return {
-    worker,
-    on(event, listener) {
-      this.worker.on(event, listener)
-    },
-    send(message) {
-      this.worker.postMessage(message)
-    },
-    sendAndTransfer(message, transfer) {
-      this.worker.postMessage(message, transfer)
-    },
-    dispose() {
-      this.worker.terminate()
-    },
-  }
-}