@lvce-editor/file-system-process 3.7.0 → 4.0.0

package/dist/index.js

@@ -218,18 +218,22 @@ const isEnoentError = error => {
 
 const FileSystemProcess = 210;
 const MainProcess = -5;
-const SharedProcess$1 = 1;
+const SharedProcess$1 = 1492;
 
 const rpcs = Object.create(null);
-const set$2 = (id, rpc) => {
+const set$1 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
   return rpcs[id];
 };
 
-const create$6 = rpcId => {
+const create$3 = rpcId => {
   return {
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
+    },
     // @ts-ignore
     invoke(method, ...params) {
       const rpc = get$1(rpcId);
@@ -243,11 +247,7 @@ const create$6 = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$2(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get$1(rpcId);
-      await rpc.dispose();
+      set$1(rpcId, rpc);
     }
   };
 };
@@ -429,8 +429,8 @@ const getModuleNotFoundError = stderr => {
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
 };
 const isModuleNotFoundError = stderr => {
@@ -453,14 +453,14 @@ const isUnhelpfulNativeModuleError = stderr => {
 const getNativeModuleErrorMessage = stderr => {
   const message = getMessageCodeBlock(stderr);
   return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
   };
 };
 const getModuleSyntaxError = () => {
   return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
   };
 };
 const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -479,8 +479,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -490,8 +490,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -729,8 +729,8 @@ const removeListener = (emitter, type, callback) => {
 };
 const getFirstEvent = (eventEmitter, eventMap) => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   const listenerMap = Object.create(null);
   const cleanup = value => {
@@ -742,8 +742,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   for (const [event, type] of Object.entries(eventMap)) {
     const listener = event => {
       cleanup({
-        type,
-        event
+        event,
+        type
       });
     };
     addListener(eventEmitter, event, listener);
@@ -759,28 +759,28 @@ const getFirstWebSocketEvent = async webSocket => {
     WebSocket
   } = await import('ws');
   switch (webSocket.readyState) {
-    case WebSocket.OPEN:
+    case WebSocket.CLOSED:
       return {
-        type: Open,
-        event: undefined
+        event: undefined,
+        type: Close
       };
-    case WebSocket.CLOSED:
+    case WebSocket.OPEN:
       return {
-        type: Close,
-        event: undefined
+        event: undefined,
+        type: Open
       };
   }
   // @ts-ignore
   const {
-    type,
-    event
+    event,
+    type
   } = await getFirstEvent(webSocket, {
-    open: Open,
-    close: Close
+    close: Close,
+    open: Open
   });
   return {
-    type,
-    event
+    event,
+    type
   };
 };
 
@@ -810,8 +810,8 @@ const handleUpgrade$1 = async (...args) => {
   return module.handleUpgrade(...args);
 };
 const listen$1$1 = async ({
-  request,
-  handle
+  handle,
+  request
 }) => {
   if (!request) {
     throw new IpcError('request must be defined');
@@ -831,14 +831,19 @@ const signal$4 = webSocket => {
 };
 const wrap$9 = webSocket => {
   return {
-    webSocket,
-    /**
-     * @type {any}
-     */
-    wrappedListener: undefined,
+    dispose() {
+      this.webSocket.close();
+    },
+    // @ts-ignore
+    off(event, listener) {
+      this.webSocket.off(event, listener);
+    },
     // @ts-ignore
     on(event, listener) {
       switch (event) {
+        case 'close':
+          webSocket.on('close', listener);
+          break;
         case 'message':
           // @ts-ignore
           const wrappedListener = message => {
@@ -851,28 +856,23 @@ const wrap$9 = webSocket => {
           };
           webSocket.on('message', wrappedListener);
           break;
-        case 'close':
-          webSocket.on('close', listener);
-          break;
         default:
           throw new Error('unknown event listener type');
       }
     },
     // @ts-ignore
-    off(event, listener) {
-      this.webSocket.off(event, listener);
-    },
-    // @ts-ignore
     send(message) {
       const stringifiedMessage = serialize(message);
       this.webSocket.send(stringifiedMessage);
     },
-    dispose() {
-      this.webSocket.close();
-    },
     start() {
       throw new Error('start method is deprecated');
-    }
+    },
+    webSocket,
+    /**
+     * @type {any}
+     */
+    wrappedListener: undefined
   };
 };
 const IpcChildWithWebSocket = {
@@ -882,56 +882,14 @@ const IpcChildWithWebSocket = {
   wrap: wrap$9
 };
 
-const Two = '2.0';
-const create$4 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
+const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const set$1 = (id, fn) => {
-  callbacks[id] = fn;
-};
 const get = id => {
   return callbacks[id];
 };
 const remove$1 = id => {
   delete callbacks[id];
 };
-let id = 0;
-const create$3 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$1(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
-};
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
@@ -1127,7 +1085,7 @@ const getErrorProperty = (error, prettyError) => {
 };
 const create$1 = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error
   };
@@ -1138,20 +1096,20 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1(id, errorProperty);
 };
-const create$5 = (message, result) => {
+const create$2 = (message, result) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id: message.id,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$5(message, resultProperty);
+  return create$2(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error: {
       code: Custom,
@@ -1238,29 +1196,6 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send = (transport, method, ...params) => {
-  const message = create$4(method, params);
-  transport.send(message);
-};
-const invoke$3 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer$2 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -1283,24 +1218,87 @@ const execute = (command, ...args) => {
   return fn(...args);
 };
 
+const Two = '2.0';
+const create$s = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const create$r = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+let id = 0;
+const create$q = () => {
+  return ++id;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise = map => {
+  const id = create$q();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$r(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
 const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
   const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
     // @ts-ignore
     ipc,
     /**
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$3(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$2(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$s(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
@@ -1317,7 +1315,7 @@ const logError = () => {
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket$1;
   const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
@@ -1335,7 +1333,7 @@ const listen$2 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$k = async ({
+const create$p = async ({
   commandMap,
   messagePort,
   requiresSocket
@@ -1354,9 +1352,9 @@ const create$k = async ({
 };
 const ElectronMessagePortRpcClient = {
   __proto__: null,
-  create: create$k
+  create: create$p
 };
-const create$j = async ({
+const create$o = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1368,9 +1366,29 @@ const create$j = async ({
 };
 const ElectronUtilityProcessRpcClient = {
   __proto__: null,
-  create: create$j
+  create: create$o
+};
+const create$k = async ({
+  commandMap,
+  getPortTuple,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = await getPortTuple();
+  await send(port1);
+  const rpc = create$p({
+    commandMap,
+    messagePort: port2
+  });
+  return rpc;
+};
+const TransferElectronMessagePortRpc = {
+  __proto__: null,
+  create: create$k
 };
-const create$a = async ({
+const create$9 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1382,19 +1400,19 @@ const create$a = async ({
 };
 const NodeForkedProcessRpcClient = {
   __proto__: null,
-  create: create$a
+  create: create$9
 };
-const create$8 = async ({
+const create$7 = async ({
   commandMap,
-  request,
   handle,
+  request,
   requiresSocket
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
   const ipc = await listen$2(IpcChildWithWebSocket, {
-    request,
-    handle
+    handle,
+    request
   });
   if (requiresSocket) {
     ipc.requiresSocket = requiresSocket;
@@ -1405,9 +1423,9 @@ const create$8 = async ({
 };
 const NodeWebSocketRpcClient = {
   __proto__: null,
-  create: create$8
+  create: create$7
 };
-const create$7 = async ({
+const create$6 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1419,15 +1437,15 @@ const create$7 = async ({
 };
 const NodeWorkerRpcClient = {
   __proto__: null,
-  create: create$7
+  create: create$6
 };
 
 const {
+  dispose,
   invoke: invoke$2,
   invokeAndTransfer: invokeAndTransfer$1,
-  set,
-  dispose
-} = create$6(SharedProcess$1);
+  set
+} = create$3(SharedProcess$1);
 
 const SharedProcess = {
   __proto__: null,
@@ -1442,7 +1460,7 @@ const createLazyRpc = rpcId => {
   let factory;
   const createRpc = async () => {
     const rpc = await factory();
-    set$2(rpcId, rpc);
+    set$1(rpcId, rpc);
   };
   const ensureRpc = async () => {
     if (!rpcPromise) {
@@ -1451,13 +1469,18 @@ const createLazyRpc = rpcId => {
     await rpcPromise;
   };
   return {
-    setFactory(value) {
-      factory = value;
-    },
     async invoke(method, ...params) {
       await ensureRpc();
       const rpc = get$1(rpcId);
       return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      await ensureRpc();
+      const rpc = get$1(rpcId);
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    setFactory(value) {
+      factory = value;
     }
   };
 };
@@ -1551,6 +1574,19 @@ const writeFile = async (uri, content, encoding = Utf8) => {
     throw new VError(error, `Failed to write to file "${uri}"`);
   }
 };
+const writeBuffer = async (uri, buffer) => {
+  try {
+    assertUri(uri);
+    string(uri);
+    const path = fileURLToPath(uri);
+    await fs.writeFile(path, buffer);
+  } catch (error) {
+    if (isEnoentError(error)) {
+      throw new FileNotFoundError(uri);
+    }
+    throw new VError(error, `Failed to write to file "${uri}"`);
+  }
+};
 const appendFile = async (uri, content) => {
   try {
     assertUri(uri);
@@ -1749,14 +1785,14 @@ const Auto = argv => {
 
 const getModule = method => {
   switch (method) {
+    case ElectronMessagePort:
+      return ElectronMessagePortRpcClient.create;
+    case ElectronUtilityProcess:
+      return ElectronUtilityProcessRpcClient.create;
     case NodeForkedProcess:
       return NodeForkedProcessRpcClient.create;
     case NodeWorker:
       return NodeWorkerRpcClient.create;
-    case ElectronUtilityProcess:
-      return ElectronUtilityProcessRpcClient.create;
-    case ElectronMessagePort:
-      return ElectronMessagePortRpcClient.create;
     case WebSocket:
       return NodeWebSocketRpcClient.create;
     default:
@@ -1776,11 +1812,11 @@ const listen$1 = async ({
 const handleElectronMessagePort = async (messagePort, rpcId) => {
   object(messagePort);
   const rpc = await listen$1({
-    method: ElectronMessagePort,
-    messagePort
+    messagePort,
+    method: ElectronMessagePort
   });
   if (rpcId) {
-    set$2(rpcId, rpc);
+    set$1(rpcId, rpc);
   }
 };
 
@@ -1791,9 +1827,9 @@ const handleWebSocket = async (handle, request) => {
   object(handle);
   object(request);
   await listen$1({
+    handle,
     method: WebSocket,
     request,
-    handle,
     requiresSocket
   });
 };
@@ -1807,8 +1843,7 @@ const create = () => {
 
 const {
   invoke,
-  invokeAndTransfer
-} = SharedProcess;
+  invokeAndTransfer} = SharedProcess;
 
 const ports = Object.create(null);
 const getPortTuple$1 = async () => {
@@ -1847,16 +1882,14 @@ const getPortTuple = async () => {
 
 const createMainProcessRpc = async () => {
   try {
-    const {
-      port1,
-      port2
-    } = await getPortTuple();
-    await invokeAndTransfer(
-    // @ts-ignore
-    'TemporaryMessagePort.sendToElectron', port1, MainProcess, FileSystemProcess);
-    const rpc = await ElectronMessagePortRpcClient.create({
+    const rpc = TransferElectronMessagePortRpc.create({
       commandMap: {},
-      messagePort: port2
+      getPortTuple,
+      async send(port) {
+        await invokeAndTransfer(
+        // @ts-ignore
+        'TemporaryMessagePort.sendToElectron', port, MainProcess, FileSystemProcess);
+      }
     });
     return rpc;
   } catch (error) {
@@ -1884,6 +1917,7 @@ const commandMap = {
   'FileSystem.stat': stat,
   'FileSystem.unwatchFile': unwatchFile,
   'FileSystem.watchFile': watchFile,
+  'FileSystem.writeBuffer': writeBuffer,
   'FileSystem.writeFile': writeFile,
   'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort,
   'HandleWebSocket.handleWebSocket': handleWebSocket,
@@ -1893,8 +1927,8 @@ const commandMap = {
 
 const listen = async argv => {
   await listen$1({
-    method: Auto(argv),
-    commandMap: commandMap
+    commandMap: commandMap,
+    method: Auto(argv)
   });
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-system-process",
-  "version": "3.7.0",
+  "version": "4.0.0",
   "description": "File System Process",
   "keywords": [
     "Lvce Editor",
@@ -18,8 +18,8 @@
     "file-system-process": "bin/fileSystemProcess.js"
   },
   "dependencies": {
-    "trash": "^10.0.0",
-    "ws": "^8.18.3"
+    "trash": "^10.0.1",
+    "ws": "^8.19.0"
   },
   "engines": {
     "node": ">=22"