@lvce-editor/main-process 6.23.0 → 6.25.0

package/dist/mainProcessMain.js

@@ -9,6 +9,7 @@ import { mkdirSync, createWriteStream, readFileSync, openAsBlob, existsSync, wri
 import * as NodePath from 'node:path';
 import { dirname, join as join$1, isAbsolute } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
+import { readFile } from 'node:fs/promises';
 import { pbkdf2Sync, createDecipheriv, createHash } from 'node:crypto';
 import { DatabaseSync } from 'node:sqlite';
 import { MessageChannel } from 'node:worker_threads';
@@ -796,11 +797,15 @@ const isProduction = false;
 const homeDirectory = homedir();
 
 const xdgCache = env.XDG_CACHE_HOME || (homeDirectory ? join(homeDirectory, '.cache') : undefined);
+const xdgConfig = env.XDG_CONFIG_HOME || (homeDirectory ? join(homeDirectory, '.config') : undefined);
 const xdgData = env.XDG_DATA_HOME || (homeDirectory ? join(homeDirectory, '.local', 'share') : undefined);
 join(xdgData || tmpdir(), applicationName);
 const xdgState = env.XDG_STATE_HOME || (homeDirectory ? join(homeDirectory, '.local', 'state') : undefined);
 const logsDir = join(xdgState || tmpdir(), applicationName, 'logs');
 const chromeUserDataPath = xdgCache ? join(xdgCache, applicationName, 'userdata') : '';
+const getArgvConfigPath = () => {
+  return join(xdgConfig || tmpdir(), applicationName, 'argv.json');
+};
 
 const useIpcForResponse = true;
 const getSessionId = () => {
@@ -1598,7 +1603,7 @@ const Array$1 = 3;
 const String$1 = 4;
 const Boolean$1 = 5;
 const Function$1 = 6;
-const Null = 7;
+const Null$1 = 7;
 const Unknown$1 = 8;
 const getType = value => {
   switch (typeof value) {
@@ -1610,7 +1615,7 @@ const getType = value => {
       return String$1;
     case 'object':
       if (value === null) {
-        return Null;
+        return Null$1;
       }
       if (Array.isArray(value)) {
         return Array$1;
@@ -2267,7 +2272,7 @@ const IpcChildWithNodeWorker$1 = {
   wrap: wrap$b
 };
 const preloadChannelType = 'port';
-const listen$2 = ({
+const listen$2$1 = ({
   webContents
 }) => {
   return webContents;
@@ -2309,7 +2314,7 @@ const wrap$a = webContents => {
 };
 const IpcChildWithRendererProcess2$1 = {
   __proto__: null,
-  listen: listen$2,
+  listen: listen$2$1,
   wrap: wrap$a
 };
 const addListener$1 = (emitter, type, callback) => {
@@ -2814,7 +2819,7 @@ const execute$1 = (command, ...args) => {
   return fn(...args);
 };
 
-const Two$1 = '2.0';
+const Two$2 = '2.0';
 const callbacks = Object.create(null);
 const set$2 = (id, fn) => {
   callbacks[id] = fn;
@@ -2850,7 +2855,7 @@ const create$2$1 = (method, params) => {
   } = registerPromise$1();
   const message = {
     id,
-    jsonrpc: Two$1,
+    jsonrpc: Two$2,
     method,
     params
   };
@@ -3097,7 +3102,7 @@ const create$1$1 = (id, error) => {
   return {
     error,
     id,
-    jsonrpc: Two$1
+    jsonrpc: Two$2
   };
 };
 const getErrorResponse = (id, error, preparePrettyError, logError) => {
@@ -3109,7 +3114,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
 const create$9 = (message, result) => {
   return {
     id: message.id,
-    jsonrpc: Two$1,
+    jsonrpc: Two$2,
     result: result ?? null
   };
 };
@@ -3126,7 +3131,7 @@ const getErrorResponseSimple = (id, error) => {
       message: error.message
     },
     id,
-    jsonrpc: Two$1
+    jsonrpc: Two$2
   };
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
@@ -3223,11 +3228,11 @@ const invokeAndTransfer$1 = (ipc, method, ...params) => {
   return invokeHelper$1(ipc, method, params);
 };
 
-const Two = '2.0';
+const Two$1 = '2.0';
 
 const create$8 = (method, params) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     method,
     params
   };
@@ -3236,7 +3241,7 @@ const create$8 = (method, params) => {
 const create$7 = (id, method, params) => {
   const message = {
     id,
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     method,
     params
   };
@@ -3333,7 +3338,7 @@ const handleIpc$1 = ipc => {
   }
 };
 
-const listen$1 = async (module, options) => {
+const listen$2 = async (module, options) => {
   const rawIpc = await module.listen(options);
   if (module.signal) {
     module.signal(rawIpc);
@@ -3349,7 +3354,7 @@ const create$5 = async ({
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$1(IpcChildWithElectronMessagePort$1, {
+  const ipc = await listen$2(IpcChildWithElectronMessagePort$1, {
     messagePort
   });
   if (requiresSocket) {
@@ -3408,13 +3413,13 @@ const create$3 = async ({
 const commandMapRef = Object.create(null);
 
 const Dash = '-';
-const Space$2 = ' ';
+const Space$3 = ' ';
 
 const firstLetterLowerCase = string => {
   return string[0].toLowerCase() + string.slice(1);
 };
 const camelCase = string => {
-  const parts = string.split(Space$2);
+  const parts = string.split(Space$3);
   const lowerParts = parts.map(firstLetterLowerCase);
   return lowerParts.join(Dash);
 };
@@ -3490,7 +3495,10 @@ const getPortTuple = () => {
   };
 };
 
-const getSharedProcessArgv = isProduction => {
+const getSharedProcessArgv = argv => {
+  return argv.slice(1);
+};
+const getSharedProcessExecArgv = isProduction => {
   return [];
 };
 
@@ -3553,13 +3561,14 @@ const launchSharedProcess = async ({
 }) => {
   mark(WillStartSharedProcess);
   const sharedProcessPath = getSharedProcessPath();
-  const execArgv = getSharedProcessArgv();
+  const argv = getSharedProcessArgv(getArgv());
+  const execArgv = getSharedProcessExecArgv();
   const fullEnv = {
     ...process.env,
     ...env
   };
   const sharedProcessRpc = await createElectronUtilityProcessRpc({
-    argv: [],
+    argv,
     commandMap: commandMapRef,
     env: fullEnv,
     execArgv,
@@ -3654,7 +3663,7 @@ const CliForwardToSharedProcess = {
 };
 
 const SharedProcess = 4;
-const None = 0;
+const None$1 = 0;
 
 const on = (event, listener) => {
   app.on(event, listener);
@@ -3687,7 +3696,7 @@ const getCliModuleId = parsedArgs => {
   if (arg0 === Install || arg0 === List || arg0 === Link || arg0 === Unlink || parsedArgs[Status] || parsedArgs[Version] || parsedArgs[Help] || parsedArgs[Web] || parsedArgs[BuiltinSelfTest]) {
     return SharedProcess;
   }
-  return None;
+  return None$1;
 };
 
 const getModule$3 = moduleId => {
@@ -4278,6 +4287,378 @@ const hydrate = async (isLinux, chromeUserDataPath, argv) => {
 const {
   argv
 } = process;
+const getInsertionIndex = () => {
+  if (argv[0].endsWith('dist/electron') || argv[0].endsWith('dist\\electron.exe')) {
+    return 2;
+  }
+  return 1;
+};
+const prepend = argumentsToPrepend => {
+  argv.splice(getInsertionIndex(), 0, ...argumentsToPrepend);
+};
+
+const CurlyOpen$1 = '{'.charCodeAt(0);
+const CurlyClose$1 = '}'.charCodeAt(0);
+const SquareOpen$1 = '['.charCodeAt(0);
+const SquareClose$1 = ']'.charCodeAt(0);
+const DoubleQuote$1 = '"'.charCodeAt(0);
+const Comma$1$1 = ','.charCodeAt(0);
+const Zero = '0'.charCodeAt(0);
+const One = '1'.charCodeAt(0);
+const Two = '2'.charCodeAt(0);
+const Three = '3'.charCodeAt(0);
+const Four = '4'.charCodeAt(0);
+const Five = '5'.charCodeAt(0);
+const Six = '6'.charCodeAt(0);
+const Seven = '7'.charCodeAt(0);
+const Eight = '8'.charCodeAt(0);
+const Nine = '9'.charCodeAt(0);
+const Dot = '.'.charCodeAt(0);
+const CarriageReturn = '\r'.charCodeAt(0);
+const LineFeed = '\n'.charCodeAt(0);
+const Space$2 = ' '.charCodeAt(0);
+const Tab$2 = '\t'.charCodeAt(0);
+const Slash$1$1 = '/'.charCodeAt(0);
+const Star$2 = '*'.charCodeAt(0);
+const None = 0;
+const CurlyOpen = 1;
+const CurlyClose = 2;
+const Eof = 3;
+const SquareOpen = 4;
+const SquareClose = 5;
+const DoubleQuote = 6;
+const Comma$2 = 7;
+const Numeric = 8;
+const Slash$2 = 9;
+const Literal = 10;
+const createScanner = text => {
+  let offset = 0;
+  const length = text.length;
+  const scanValue = () => {
+    while (offset < length) {
+      const code = text.charCodeAt(offset);
+      switch (code) {
+        case CurlyOpen$1:
+          offset++;
+          return CurlyOpen;
+        case CurlyClose$1:
+          offset++;
+          return CurlyClose;
+        case SquareOpen$1:
+          offset++;
+          return SquareOpen;
+        case SquareClose$1:
+          offset++;
+          return SquareClose;
+        case DoubleQuote$1:
+          offset++;
+          return DoubleQuote;
+        case Comma$1$1:
+          offset++;
+          return Comma$2;
+        case Zero:
+        case One:
+        case Two:
+        case Three:
+        case Four:
+        case Five:
+        case Six:
+        case Seven:
+        case Eight:
+        case Nine:
+        case Dot:
+          offset++;
+          return Numeric;
+        case CarriageReturn:
+        case LineFeed:
+        case Tab$2:
+        case Space$2:
+          offset++;
+          break;
+        case Slash$1$1:
+          return Slash$2;
+        default:
+          return Literal;
+      }
+    }
+    return Eof;
+  };
+  const scanString = () => {
+    while (offset < length) {
+      const code = text.charCodeAt(offset);
+      if (code === DoubleQuote$1) {
+        break;
+      }
+      offset++;
+    }
+    offset++;
+    const start = offset;
+    while (offset < length) {
+      const code = text.charCodeAt(offset);
+      if (code === DoubleQuote$1) {
+        break;
+      }
+      offset++;
+    }
+    const result = text.slice(start, offset);
+    offset++;
+    return result;
+  };
+  const scanPropertyName = () => {
+    return scanString();
+  };
+  const scanPropertyColon = () => {
+    text.charCodeAt(offset);
+    offset++;
+  };
+  const goBack = delta => {
+    offset -= delta;
+  };
+  const scanNumber = () => {
+    const start = offset;
+    outer: while (offset < length) {
+      const code = text.charCodeAt(offset);
+      switch (code) {
+        case Zero:
+        case One:
+        case Two:
+        case Three:
+        case Four:
+        case Five:
+        case Six:
+        case Seven:
+        case Eight:
+        case Nine:
+        case Dot:
+          break;
+        default:
+          break outer;
+      }
+      offset++;
+    }
+    const result = text.slice(start, offset);
+    return result;
+  };
+  const scanLiteral = () => {
+    const start = offset;
+    outer: while (offset < length) {
+      const code = text.charCodeAt(offset);
+      switch (code) {
+        case LineFeed:
+        case CarriageReturn:
+        case Tab$2:
+        case Space$2:
+        case Comma$1$1:
+          break outer;
+      }
+      offset++;
+    }
+    const result = text.slice(start, offset);
+    return result;
+  };
+  const scanBlockComment = () => {
+    while (offset < length) {
+      if (text.charCodeAt(offset) === Star$2 && text.charCodeAt(offset + 1) === Slash$1$1) {
+        break;
+      }
+      offset++;
+    }
+  };
+  const scanLineComment = () => {
+    while (offset < length) {
+      const code = text.charCodeAt(offset);
+      if (code === LineFeed) {
+        break;
+      }
+      offset++;
+    }
+  };
+  const scanComment = () => {
+    const code = text.charCodeAt(offset);
+    switch (code) {
+      case Star$2:
+        return scanBlockComment();
+      case Slash$1$1:
+        return scanLineComment();
+    }
+  };
+  return {
+    scanValue,
+    scanPropertyName,
+    scanPropertyColon,
+    scanString,
+    scanNumber,
+    goBack,
+    scanLiteral,
+    scanComment,
+    getOffset() {
+      return offset;
+    }
+  };
+};
+const parseComment = scanner => {
+  scanner.scanComment();
+};
+const True = 'true';
+const False = 'false';
+const Null = 'null';
+const parseLiteral = scanner => {
+  const rawValue = scanner.scanLiteral();
+  switch (rawValue) {
+    case True:
+      return true;
+    case False:
+      return false;
+    case Null:
+      return null;
+    default:
+      return undefined;
+  }
+};
+const parseNumber = scanner => {
+  scanner.goBack(1);
+  const rawValue = scanner.scanNumber();
+  const value = Number.parseFloat(rawValue);
+  return value;
+};
+const parsePropertyColon = scanner => {
+  scanner.scanPropertyColon();
+};
+const parsePropertyName = scanner => {
+  const propertyName = scanner.scanPropertyName();
+  return propertyName;
+};
+const parseString = scanner => {
+  scanner.goBack(1);
+  const value = scanner.scanString();
+  return value;
+};
+const parseObject = scanner => {
+  const object = {};
+  outer: while (true) {
+    const token = scanner.scanValue();
+    switch (token) {
+      case Eof:
+      case None:
+      case CurlyClose:
+        break outer;
+      case DoubleQuote:
+        scanner.goBack(1);
+        const propertyName = parsePropertyName(scanner);
+        parsePropertyColon(scanner);
+        const value = parseValue(scanner);
+        object[propertyName] = value;
+      case Comma$2:
+        break;
+      case Slash$2:
+        parseComment(scanner);
+        break;
+      case Literal:
+        parseLiteral(scanner);
+        break;
+    }
+  }
+  return object;
+};
+const parseArray = scanner => {
+  const array = [];
+  outer: while (true) {
+    const token = scanner.scanValue();
+    switch (token) {
+      case Eof:
+      case None:
+      case SquareClose:
+        break outer;
+      case Slash$2:
+        scanner.scanComment();
+        break;
+      case Comma$2:
+        break;
+      default:
+        scanner.goBack(1);
+        const value = parseValue(scanner);
+        array.push(value);
+        break;
+    }
+  }
+  return array;
+};
+const parseValue = scanner => {
+  const token = scanner.scanValue();
+  switch (token) {
+    case CurlyOpen:
+      return parseObject(scanner);
+    case DoubleQuote:
+      return parseString(scanner);
+    case Numeric:
+      return parseNumber(scanner);
+    case SquareOpen:
+      return parseArray(scanner);
+    case Literal:
+      return parseLiteral(scanner);
+    case Slash$2:
+      parseComment(scanner);
+      return parseValue(scanner);
+    default:
+      return undefined;
+  }
+};
+const parse = text => {
+  const scanner = createScanner(text);
+  const result = parseValue(scanner);
+  return result;
+};
+
+// @ts-ignore
+const appliedEnvironmentVariable = 'LVCE_ARGV_CONFIG_APPLIED';
+const keyPattern = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+const getArgument = (key, value) => {
+  return `--${key}=${value}`;
+};
+const getArgumentsForValue = (key, value) => {
+  if (value === true) {
+    return [`--${key}`];
+  }
+  if (value === false) {
+    return [];
+  }
+  if (typeof value === 'string' || typeof value === 'number') {
+    return [getArgument(key, value)];
+  }
+  if (Array.isArray(value) && value.every(item => typeof item === 'string' || typeof item === 'number')) {
+    return value.map(item => getArgument(key, item));
+  }
+  throw new TypeError(`Invalid argv.json value for "${key}": expected a boolean, string, number, or array of strings and numbers`);
+};
+const parseArgvConfig = content => {
+  const config = parse(content);
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    throw new TypeError('Invalid argv.json: expected an object');
+  }
+  const argumentsFromConfig = [];
+  for (const [key, value] of Object.entries(config)) {
+    if (!keyPattern.test(key)) {
+      throw new TypeError(`Invalid argv.json key "${key}"`);
+    }
+    argumentsFromConfig.push(...getArgumentsForValue(key, value));
+  }
+  return argumentsFromConfig;
+};
+const load = async (path, env = process.env) => {
+  if (env[appliedEnvironmentVariable] === '1') {
+    return [];
+  }
+  env[appliedEnvironmentVariable] = '1';
+  try {
+    const content = await readFile(path, 'utf8');
+    return parseArgvConfig(content);
+  } catch (error) {
+    if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+      return [];
+    }
+    throw error;
+  }
+};
 
 const accessControlAllowOrigin = 'access-control-allow-origin';
 const getCorsResponseHeaders = (responseHeaders = {}) => {
@@ -4499,6 +4880,21 @@ const registerWebviewProtocol = async port => {
   handle(session.protocol, WebView, handleRequest);
 };
 
+const listen$1 = (browserWindow, rpc) => {
+  const handleEnterFullScreen = () => {
+    rpc.send('Window.handleFullScreenChange', true);
+  };
+  const handleLeaveFullScreen = () => {
+    rpc.send('Window.handleFullScreenChange', false);
+  };
+  browserWindow.on('enter-full-screen', handleEnterFullScreen);
+  browserWindow.on('leave-full-screen', handleLeaveFullScreen);
+  return () => {
+    browserWindow.off('enter-full-screen', handleEnterFullScreen);
+    browserWindow.off('leave-full-screen', handleLeaveFullScreen);
+  };
+};
+
 class WindowLoadError extends VError {
   constructor(error, url) {
     super(error, `Failed to load url ${url}`);
@@ -4595,19 +4991,20 @@ const createAppWindow = async (windowOptions, parsedArgs, workingDirectory, titl
   // window.setMenu(menu)
   window.setMenuBarVisibility(true);
   window.setAutoHideMenuBar(false);
-  // TODO send event to shared process
+  const rpc = await create$3({
+    commandMap: commandMapRef,
+    webContents: window.webContents
+  });
+  const disposeFullScreenListener = listen$1(window, rpc);
   const handleWindowClose = () => {
     try {
+      disposeFullScreenListener();
       window.off('close', handleWindowClose);
     } catch (error) {
       handleError(new VError(error, `Failed to run window close listener`));
     }
   };
   window.on('close', handleWindowClose);
-  await create$3({
-    commandMap: commandMapRef,
-    webContents: window.webContents
-  });
   await loadUrl(window, url);
 };
 
@@ -7488,6 +7885,8 @@ const setStackTraceLimit = value => {
 // @ts-ignore
 performance.mark('code/start');
 const main = async () => {
+  const configArguments = await load(getArgvConfigPath());
+  prepend(configArguments);
   Object.assign(commandMapRef, commandMap);
   setStackTraceLimit(20);
   on$1('uncaughtExceptionMonitor', handleUncaughtExceptionMonitor);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/main-process",
-  "version": "6.23.0",
+  "version": "6.25.0",
   "keywords": [
     "lvce-editor",
     "electron"