@lvce-editor/file-system-process 5.0.0 → 5.1.0

package/dist/index.js

@@ -747,6 +747,27 @@ const IpcChildWithWebSocket = {
   wrap: wrap$9
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
 const Two$1 = '2.0';
 const callbacks = Object.create(null);
 const get$1 = id => {
@@ -771,12 +792,12 @@ const getErrorConstructor = (message, type) => {
     switch (type) {
       case DomException:
         return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
       case ReferenceError$1:
         return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
       default:
         return Error;
     }
@@ -932,27 +953,27 @@ const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
       code: MethodNotFound,
-      message: error.message,
-      data: error.stack
+      data: error.stack,
+      message: error.message
     };
   }
   return {
     code: Custom,
-    message: prettyError.message,
     data: {
-      stack: getStack(prettyError),
-      codeFrame: prettyError.codeFrame,
-      type: getErrorType(prettyError),
       code: prettyError.code,
-      name: prettyError.name
-    }
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
   };
 };
 const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two$1,
+    error,
     id,
-    error
+    jsonrpc: Two$1
   };
 };
 const getErrorResponse = (id, error, preparePrettyError, logError) => {
@@ -961,27 +982,27 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$2 = (message, result) => {
+const create$c = (message, result) => {
   return {
-    jsonrpc: Two$1,
     id: message.id,
+    jsonrpc: Two$1,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$2(message, resultProperty);
+  return create$c(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two$1,
-    id,
     error: {
       code: Custom,
+      data: error,
       // @ts-ignore
-      message: error.message,
-      data: error
-    }
+      message: error.message
+    },
+    id,
+    jsonrpc: Two$1
   };
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
@@ -1011,35 +1032,35 @@ const normalizeParams = args => {
   if (args.length === 1) {
     const options = args[0];
     return {
+      execute: options.execute,
       ipc: options.ipc,
+      logError: options.logError || defaultLogError,
       message: options.message,
-      execute: options.execute,
-      resolve: options.resolve || defaultResolve,
       preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      logError: options.logError || defaultLogError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
     };
   }
   return {
+    execute: args[2],
     ipc: args[0],
+    logError: args[5],
     message: args[1],
-    execute: args[2],
-    resolve: args[3],
     preparePrettyError: args[4],
-    logError: args[5],
-    requiresSocket: args[6]
+    requiresSocket: args[6],
+    resolve: args[3]
   };
 };
 const handleJsonRpcMessage = async (...args) => {
   const options = normalizeParams(args);
   const {
-    message,
-    ipc,
     execute,
-    resolve,
-    preparePrettyError,
+    ipc,
     logError,
-    requiresSocket
+    message,
+    preparePrettyError,
+    requiresSocket,
+    resolve
   } = options;
   if ('id' in message) {
     if ('method' in message) {
@@ -1062,36 +1083,17 @@ const handleJsonRpcMessage = async (...args) => {
   throw new JsonRpcError('unexpected message');
 };
 
-class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    this.name = 'CommandNotFoundError';
-  }
-}
-const commands = Object.create(null);
-const register = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new CommandNotFoundError(command);
-  }
-  return fn(...args);
-};
-
 const Two = '2.0';
-const create$s = (method, params) => {
+
+const create$b = (method, params) => {
   return {
     jsonrpc: Two,
     method,
     params
   };
 };
-const create$r = (id, method, params) => {
+
+const create$a = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -1100,15 +1102,14 @@ const create$r = (id, method, params) => {
   };
   return message;
 };
+
 let id = 0;
-const create$q = () => {
+const create$9 = () => {
   return ++id;
 };
 
-/* eslint-disable n/no-unsupported-features/es-syntax */
-
 const registerPromise = map => {
-  const id = create$q();
+  const id = create$9();
   const {
     promise,
     resolve
@@ -1120,13 +1121,12 @@ const registerPromise = map => {
   };
 };
 
-// @ts-ignore
 const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
   const {
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$r(id, method, params);
+  const message = create$a(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -1162,12 +1162,13 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$s(method, params);
+      const message = create$b(method, params);
       ipc.send(message);
     }
   };
   return rpc;
 };
+
 const requiresSocket$1 = () => {
   return false;
 };
@@ -1182,6 +1183,7 @@ const handleMessage = event => {
   const actualExecute = event?.target?.execute || execute;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
+
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
     ipc.addEventListener('message', handleMessage);
@@ -1190,6 +1192,7 @@ const handleIpc = ipc => {
     ipc.on('message', handleMessage);
   }
 };
+
 const listen$1 = async (module, options) => {
   const rawIpc = await module.listen(options);
   if (module.signal) {
@@ -1198,7 +1201,8 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$p = async ({
+
+const create$8 = async ({
   commandMap,
   messagePort,
   requiresSocket
@@ -1215,11 +1219,8 @@ const create$p = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const ElectronMessagePortRpcClient = {
-  __proto__: null,
-  create: create$p
-};
-const create$o = async ({
+
+const create$7 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1229,12 +1230,6 @@ const create$o = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const ElectronUtilityProcessRpcClient = {
-  __proto__: null,
-  create: create$o
-};
-
-/* eslint-disable @typescript-eslint/no-misused-promises */
 
 const createSharedLazyRpc = factory => {
   let rpcPromise;
@@ -1263,7 +1258,8 @@ const createSharedLazyRpc = factory => {
     }
   };
 };
-const create$k = async ({
+
+const create$6 = async ({
   commandMap,
   getPortTuple,
   send
@@ -1273,30 +1269,28 @@ const create$k = async ({
     port2
   } = await getPortTuple();
   await send(port1);
-  const rpc = create$p({
+  const rpc = create$8({
     commandMap,
     messagePort: port2
   });
   return rpc;
 };
-const create$j = async ({
+
+const create$5 = async ({
   commandMap,
   getPortTuple,
   send
 }) => {
   return createSharedLazyRpc(() => {
-    return create$k({
+    return create$6({
       commandMap,
       getPortTuple,
       send
     });
   });
 };
-const LazyTransferElectronMessagePortRpc = {
-  __proto__: null,
-  create: create$j
-};
-const create$9 = async ({
+
+const create$4 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1306,11 +1300,8 @@ const create$9 = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const NodeForkedProcessRpcClient = {
-  __proto__: null,
-  create: create$9
-};
-const create$7 = async ({
+
+const create$3 = async ({
   commandMap,
   handle,
   request,
@@ -1329,11 +1320,8 @@ const create$7 = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const NodeWebSocketRpcClient = {
-  __proto__: null,
-  create: create$7
-};
-const create$6 = async ({
+
+const create$2 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1343,10 +1331,7 @@ const create$6 = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const NodeWorkerRpcClient = {
-  __proto__: null,
-  create: create$6
-};
+
 const createMockRpc = ({
   commandMap
 }) => {
@@ -1367,10 +1352,6 @@ const createMockRpc = ({
   return mockRpc;
 };
 
-const FileSystemProcess = 210;
-const MainProcess = -5;
-const SharedProcess = 1492;
-
 const rpcs = Object.create(null);
 const set$2 = (id, rpc) => {
   rpcs[id] = rpc;
@@ -1419,6 +1400,10 @@ const create$1 = rpcId => {
   };
 };
 
+const FileSystemProcess = 210;
+const MainProcess = -5;
+const SharedProcess = 1492;
+
 const {
   invoke: invoke$1,
   set: set$1
@@ -1472,7 +1457,7 @@ const getPortTuple = async () => {
 };
 
 const initializeMainProcessRpc = async () => {
-  const rpc = await LazyTransferElectronMessagePortRpc.create({
+  const rpc = await create$5({
     commandMap: {},
     getPortTuple,
     async send(port) {
@@ -1855,7 +1840,7 @@ const unwatchFile = uri => {
 
 const handleElectronMessagePort = async (messagePort, rpcId) => {
   object(messagePort);
-  const rpc = await ElectronMessagePortRpcClient.create({
+  const rpc = await create$8({
     commandMap: {},
     messagePort,
     requiresSocket: false
@@ -1871,7 +1856,7 @@ const requiresSocket = method => {
 const handleWebSocket = async (handle, request) => {
   object(handle);
   object(request);
-  await NodeWebSocketRpcClient.create({
+  await create$3({
     commandMap: {},
     handle,
     request,
@@ -1909,17 +1894,17 @@ const commandMap = {
 
 const getRpc = argv => {
   if (argv.includes('--ipc-type=node-worker')) {
-    return NodeWorkerRpcClient.create({
+    return create$2({
       commandMap: commandMap
     });
   }
   if (argv.includes('--ipc-type=node-forked-process')) {
-    return NodeForkedProcessRpcClient.create({
+    return create$4({
       commandMap: commandMap
     });
   }
   if (argv.includes('--ipc-type=electron-utility-process')) {
-    return ElectronUtilityProcessRpcClient.create({
+    return create$7({
       commandMap: commandMap
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-system-process",
-  "version": "5.0.0",
+  "version": "5.1.0",
   "description": "File System Process",
   "keywords": [
     "Lvce Editor",
@@ -18,8 +18,8 @@
     "file-system-process": "bin/fileSystemProcess.js"
   },
   "dependencies": {
-    "trash": "^10.1.0",
-    "ws": "^8.19.0"
+    "trash": "^10.1.1",
+    "ws": "^8.20.0"
   },
   "engines": {
     "node": ">=24"