@lvce-editor/main-process 3.1.0 → 4.0.0

package/dist/mainProcessMain.js

@@ -1163,39 +1163,39 @@ function requireLib () {
 	const NEWLINE$1 = /\r\n|[\n\r\u2028\u2029]/;
 	const BRACKET = /^[()[\]{}]$/;
 	let tokenize;
-	{
-	  const JSX_TAG = /^[a-z][\w-]*$/i;
-	  const getTokenType = function (token, offset, text) {
-	    if (token.type === "name") {
-	      if (helperValidatorIdentifier.isKeyword(token.value) || helperValidatorIdentifier.isStrictReservedWord(token.value, true) || sometimesKeywords.has(token.value)) {
-	        return "keyword";
-	      }
-	      if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) === "</")) {
-	        return "jsxIdentifier";
-	      }
-	      if (token.value[0] !== token.value[0].toLowerCase()) {
-	        return "capitalized";
-	      }
+	const JSX_TAG = /^[a-z][\w-]*$/i;
+	const getTokenType = function (token, offset, text) {
+	  if (token.type === "name") {
+	    const tokenValue = token.value;
+	    if (helperValidatorIdentifier.isKeyword(tokenValue) || helperValidatorIdentifier.isStrictReservedWord(tokenValue, true) || sometimesKeywords.has(tokenValue)) {
+	      return "keyword";
 	    }
-	    if (token.type === "punctuator" && BRACKET.test(token.value)) {
-	      return "bracket";
+	    if (JSX_TAG.test(tokenValue) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) === "</")) {
+	      return "jsxIdentifier";
 	    }
-	    if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
-	      return "punctuator";
-	    }
-	    return token.type;
-	  };
-	  tokenize = function* (text) {
-	    let match;
-	    while (match = jsTokens.default.exec(text)) {
-	      const token = jsTokens.matchToToken(match);
-	      yield {
-	        type: getTokenType(token, match.index, text),
-	        value: token.value
-	      };
+	    const firstChar = String.fromCodePoint(tokenValue.codePointAt(0));
+	    if (firstChar !== firstChar.toLowerCase()) {
+	      return "capitalized";
 	    }
-	  };
-	}
+	  }
+	  if (token.type === "punctuator" && BRACKET.test(token.value)) {
+	    return "bracket";
+	  }
+	  if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
+	    return "punctuator";
+	  }
+	  return token.type;
+	};
+	tokenize = function* (text) {
+	  let match;
+	  while (match = jsTokens.default.exec(text)) {
+	    const token = jsTokens.matchToToken(match);
+	    yield {
+	      type: getTokenType(token, match.index, text),
+	      value: token.value
+	    };
+	  }
+	};
 	function highlight(text) {
 	  if (text === "") return "";
 	  const defs = getDefs(true);
@@ -1923,8 +1923,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 => {
@@ -1947,14 +1947,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) => {
@@ -1973,8 +1973,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -1984,8 +1984,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -2267,8 +2267,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 => {
@@ -2280,8 +2280,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);
@@ -2336,8 +2336,8 @@ const Error$2 = 2;
 const Message$1 = 3;
 const getFirstUtilityProcessEvent = async utilityProcess => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   let stdout = '';
   let stderr = '';
@@ -2358,18 +2358,18 @@ const getFirstUtilityProcessEvent = async utilityProcess => {
   };
   const handleMessage = event => {
     cleanup({
-      type: Message$1,
       event,
+      stderr,
       stdout,
-      stderr
+      type: Message$1
     });
   };
   const handleExit = event => {
     cleanup({
-      type: Exit,
       event,
+      stderr,
       stdout,
-      stderr
+      type: Exit
     });
   };
   // @ts-ignore
@@ -2379,22 +2379,22 @@ const getFirstUtilityProcessEvent = async utilityProcess => {
   utilityProcess.on('message', handleMessage);
   utilityProcess.on('exit', handleExit);
   const {
-    type,
-    event
+    event,
+    type
   } = await promise;
   return {
-    type,
     event,
+    stderr,
     stdout,
-    stderr
+    type
   };
 };
 const create$6 = async ({
-  path,
   argv = [],
+  env = process.env,
   execArgv = [],
   name,
-  env = process.env
+  path
 }) => {
   string(path);
   const actualArgv = ['--ipc-type=electron-utility-process', ...argv];
@@ -2402,10 +2402,10 @@ const create$6 = async ({
     utilityProcess
   } = await import('electron');
   const childProcess = utilityProcess.fork(path, actualArgv, {
+    env,
     execArgv,
-    stdio: 'pipe',
     serviceName: name,
-    env
+    stdio: 'pipe'
   });
   const handleExit = () => {
     // @ts-ignore
@@ -2417,9 +2417,9 @@ const create$6 = async ({
   // @ts-ignore
   childProcess.stdout.pipe(process.stdout);
   const {
-    type,
+    stderr,
     stdout,
-    stderr
+    type
   } = await getFirstUtilityProcessEvent(childProcess);
   if (type === Exit) {
     throw new IpcError(`Utility process exited before ipc connection was established`, stdout, stderr);
@@ -2465,8 +2465,8 @@ class ChildProcessError extends Error {
   constructor(stderr) {
     // @ts-ignore
     const {
-      message,
       code,
+      message,
       stack
     } = getHelpfulChildProcessError('', stderr);
     super(message || 'child process error');
@@ -2502,10 +2502,10 @@ const fixNodeChildProcessParameters = value => {
 };
 const getFirstNodeChildProcessEvent = async childProcess => {
   const {
-    type,
     event,
+    stderr,
     stdout,
-    stderr
+    type
   } = await new Promise((resolve, reject) => {
     let stderr = '';
     let stdout = '';
@@ -2527,26 +2527,26 @@ const getFirstNodeChildProcessEvent = async childProcess => {
     };
     const handleMessage = event => {
       cleanup({
-        type: Message$1,
         event,
+        stderr,
         stdout,
-        stderr
+        type: Message$1
       });
     };
     const handleExit = event => {
       cleanup({
-        type: Exit,
         event,
+        stderr,
         stdout,
-        stderr
+        type: Exit
       });
     };
     const handleError = event => {
       cleanup({
-        type: Error$2,
         event,
+        stderr,
         stdout,
-        stderr
+        type: Error$2
       });
     };
     if (childProcess.stdout && childProcess.stderr) {
@@ -2558,21 +2558,21 @@ const getFirstNodeChildProcessEvent = async childProcess => {
     childProcess.on('error', handleError);
   });
   return {
-    type,
     event,
+    stderr,
     stdout,
-    stderr
+    type
   };
 };
 
 // @ts-ignore
 const create$2$2 = async ({
-  path,
   argv = [],
   env,
   execArgv = [],
-  stdio = 'inherit',
-  name = 'child process'
+  name = 'child process',
+  path,
+  stdio = 'inherit'
 }) => {
   try {
     string(path);
@@ -2586,9 +2586,9 @@ const create$2$2 = async ({
       stdio: 'pipe'
     });
     const {
-      type,
       event,
-      stderr
+      stderr,
+      type
     } = await getFirstNodeChildProcessEvent(childProcess);
     if (type === Exit) {
       throw new ChildProcessError(stderr);
@@ -2653,18 +2653,18 @@ const fixNodeWorkerParameters = value => {
 };
 const getFirstNodeWorkerEvent = worker => {
   return getFirstEvent(worker, {
-    message: Message$1,
+    error: Error$2,
     exit: Exit,
-    error: Error$2
+    message: Message$1
   });
 };
 const create$1$2 = async ({
-  path,
   argv = [],
   env = process.env,
   execArgv = [],
-  stdio,
-  name
+  name,
+  path,
+  stdio
 }) => {
   string(path);
   const actualArgv = ['--ipc-type=node-worker', ...argv];
@@ -2680,13 +2680,13 @@ const create$1$2 = async ({
     argv: actualArgv,
     env: actualEnv,
     execArgv,
-    stdout: ignoreStdio,
+    name,
     stderr: ignoreStdio,
-    name
+    stdout: ignoreStdio
   });
   const {
-    type,
-    event
+    event,
+    type
   } = await getFirstNodeWorkerEvent(worker);
   if (type === Exit) {
     throw new IpcError(`Worker exited before ipc connection was established`);
@@ -2732,14 +2732,7 @@ const IpcParentWithNodeWorker$1 = {
   wrap: wrap$1
 };
 
-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$2 = (id, fn) => {
   callbacks[id] = fn;
@@ -2750,11 +2743,11 @@ const get$4 = id => {
 const remove$2 = id => {
   delete callbacks[id];
 };
-let id = 0;
+let id$1 = 0;
 const create$3 = () => {
-  return ++id;
+  return ++id$1;
 };
-const registerPromise = () => {
+const registerPromise$1 = () => {
   const id = create$3();
   const {
     resolve,
@@ -2770,9 +2763,9 @@ const create$2$1 = (method, params) => {
   const {
     id,
     promise
-  } = registerPromise();
+  } = registerPromise$1();
   const message = {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     method,
     params,
     id
@@ -2977,7 +2970,7 @@ const getErrorProperty = (error, prettyError) => {
 };
 const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error
   };
@@ -2988,20 +2981,20 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$5 = (message, result) => {
+const create$4 = (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$4(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error: {
       code: Custom,
@@ -3088,12 +3081,12 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
+const invokeHelper$1 = async (ipc, method, params, useSendAndTransfer) => {
   const {
     message,
     promise
   } = create$2$1(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
+  if (ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
     ipc.send(message);
@@ -3101,15 +3094,8 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const send$2 = (transport, method, ...params) => {
-  const message = create$4(method, params);
-  transport.send(message);
-};
-const invoke$1 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
 const invokeAndTransfer$1 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
+  return invokeHelper$1(ipc, method, params);
 };
 
 class CommandNotFoundError extends Error {
@@ -3133,24 +3119,87 @@ const execute$1 = (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$2(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$1(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$1(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$s(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
@@ -3167,7 +3216,7 @@ const logError$1 = () => {
 const handleMessage$1 = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket$1;
   const actualExecute = event?.target?.execute || execute$1;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError$1, actualRequiresSocket);
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError$1, actualRequiresSocket);
 };
 const handleIpc$1 = ipc => {
   if ('addEventListener' in ipc) {
@@ -3185,7 +3234,7 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$k = async ({
+const create$p = async ({
   commandMap,
   messagePort,
   requiresSocket
@@ -3204,25 +3253,25 @@ const create$k = async ({
 };
 const ElectronMessagePortRpcClient = {
   __proto__: null,
-  create: create$k
+  create: create$p
 };
-const create$i = async ({
+const create$n = async ({
+  argv,
   commandMap,
   env,
-  argv,
   execArgv,
-  path,
   name,
+  path,
   requiresSocket
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
   const rawIpc = await IpcParentWithElectronUtilityProcess$1$1.create({
-    env,
     argv,
+    env,
     execArgv,
-    path,
-    name
+    name,
+    path
   });
   const ipc = IpcParentWithElectronUtilityProcess$1$1.wrap(rawIpc);
   if (requiresSocket) {
@@ -3235,12 +3284,12 @@ const create$i = async ({
 };
 const ElectronUtilityProcessRpcParent = {
   __proto__: null,
-  create: create$i
+  create: create$n
 };
-const create$h = async ({
+const create$m = async ({
   commandMap,
-  webContents,
-  requiresSocket
+  requiresSocket,
+  webContents
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
@@ -3255,7 +3304,7 @@ const create$h = async ({
 };
 const ElectronWebContentsRpcClient = {
   __proto__: null,
-  create: create$h
+  create: create$m
 };
 
 const commandMapRef = Object.create(null);
@@ -7084,6 +7133,7 @@ const shouldOpenExternal = url => {
 };
 
 const openExternal = async url => {
+  string(url);
   if (!shouldOpenExternal(url)) {
     throw new VError(`only http or https urls are allowed`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/main-process",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "keywords": [
     "lvce-editor",
     "electron"
@@ -14,7 +14,7 @@
   "type": "module",
   "main": "dist/mainProcessMain.js",
   "dependencies": {
-    "electron": "39.2.6"
+    "electron": "40.0.0"
   },
   "engines": {
     "node": ">=22"