@lvce-editor/ipc 11.7.0 → 12.0.0

package/dist/electron.js

@@ -1,902 +0,0 @@
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const getType = value => {
-  switch (typeof value) {
-    case 'number':
-      return 'number';
-    case 'function':
-      return 'function';
-    case 'string':
-      return 'string';
-    case 'object':
-      if (value === null) {
-        return 'null';
-      }
-      if (Array.isArray(value)) {
-        return 'array';
-      }
-      return 'object';
-    case 'boolean':
-      return 'boolean';
-    default:
-      return 'unknown';
-  }
-};
-const string = value => {
-  const type = getType(value);
-  if (type !== 'string') {
-    throw new AssertionError('expected value to be of type string');
-  }
-};
-
-const Exit = 1;
-const Error$1 = 2;
-const Message = 3;
-
-const walkValue = (value, transferrables, isTransferrable) => {
-  if (!value) {
-    return;
-  }
-  if (isTransferrable(value)) {
-    transferrables.push(value);
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      walkValue(item, transferrables, isTransferrable);
-    }
-    return;
-  }
-  if (typeof value === 'object') {
-    for (const property of Object.values(value)) {
-      walkValue(property, transferrables, isTransferrable);
-    }
-    return;
-  }
-};
-
-const isMessagePort = value => {
-  return value && value instanceof MessagePort;
-};
-
-const isMessagePortMain = value => {
-  return value && value.constructor && value.constructor.name === 'MessagePortMain';
-};
-
-const isOffscreenCanvas = value => {
-  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
-};
-
-const isInstanceOf = (value, constructorName) => {
-  return value?.constructor?.name === constructorName;
-};
-
-const isSocket = value => {
-  return isInstanceOf(value, 'Socket');
-};
-
-const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
-
-const isTransferrable = value => {
-  for (const fn of transferrables) {
-    if (fn(value)) {
-      return true;
-    }
-  }
-  return false;
-};
-
-const getTransferrables = value => {
-  const transferrables = [];
-  walkValue(value, transferrables, isTransferrable);
-  return transferrables;
-};
-
-const removeValues = (value, toRemove) => {
-  if (!value) {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    const newItems = [];
-    for (const item of value) {
-      if (!toRemove.includes(item)) {
-        newItems.push(removeValues(item, toRemove));
-      }
-    }
-    return newItems;
-  }
-  if (typeof value === 'object') {
-    const newObject = Object.create(null);
-    for (const [key, property] of Object.entries(value)) {
-      if (!toRemove.includes(property)) {
-        newObject[key] = removeValues(property, toRemove);
-      }
-    }
-    return newObject;
-  }
-  return value;
-};
-
-// workaround for electron not supporting transferrable objects
-// as parameters. If the transferrable object is a parameter, in electron
-// only an empty objected is received in the main process
-const fixElectronParameters = value => {
-  const transfer = getTransferrables(value);
-  const newValue = removeValues(value, transfer);
-  return {
-    newValue,
-    transfer
-  };
-};
-
-const withResolvers = () => {
-  let _resolve;
-  const promise = new Promise(resolve => {
-    _resolve = resolve;
-  });
-  return {
-    resolve: _resolve,
-    promise
-  };
-};
-
-/**
- *
- * @param {any} utilityProcess
- * @returns
- */
-// @ts-ignore
-const getFirstUtilityProcessEvent = async utilityProcess => {
-  const {
-    resolve,
-    promise
-  } = withResolvers();
-  let stdout = '';
-  let stderr = '';
-  // @ts-ignore
-  const cleanup = value => {
-    // @ts-ignore
-    utilityProcess.stderr.off('data', handleStdErrData);
-    // @ts-ignore
-    utilityProcess.stdout.off('data', handleStdoutData);
-    utilityProcess.off('message', handleMessage);
-    utilityProcess.off('exit', handleExit);
-    // @ts-ignore
-    resolve(value);
-  };
-  // @ts-ignore
-  const handleStdErrData = data => {
-    stderr += data;
-  };
-  // @ts-ignore
-  const handleStdoutData = data => {
-    stdout += data;
-  };
-  // @ts-ignore
-  const handleMessage = event => {
-    cleanup({
-      type: Message,
-      event,
-      stdout,
-      stderr
-    });
-  };
-  // @ts-ignore
-  const handleExit = event => {
-    cleanup({
-      type: Exit,
-      event,
-      stdout,
-      stderr
-    });
-  };
-  // @ts-ignore
-  utilityProcess.stderr.on('data', handleStdErrData);
-  // @ts-ignore
-  utilityProcess.stdout.on('data', handleStdoutData);
-  utilityProcess.on('message', handleMessage);
-  utilityProcess.on('exit', handleExit);
-  // @ts-ignore
-  const {
-    type,
-    event
-  } = await promise;
-  return {
-    type,
-    event,
-    stdout,
-    stderr
-  };
-};
-
-const attachEvents = that => {
-  const handleMessage = (...args) => {
-    const data = that.getData(...args);
-    that.dispatchEvent(new MessageEvent('message', {
-      data
-    }));
-  };
-  that.onMessage(handleMessage);
-  const handleClose = event => {
-    that.dispatchEvent(new Event('close'));
-  };
-  that.onClose(handleClose);
-};
-
-class Ipc extends EventTarget {
-  constructor(rawIpc) {
-    super();
-    this._rawIpc = rawIpc;
-    attachEvents(this);
-  }
-}
-
-const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
-const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
-const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
-
-const NewLine$1 = '\n';
-
-const joinLines = lines => {
-  return lines.join(NewLine$1);
-};
-
-const splitLines = lines => {
-  return lines.split(NewLine$1);
-};
-
-const isModuleNotFoundMessage = line => {
-  return line.includes('[ERR_MODULE_NOT_FOUND]');
-};
-const getModuleNotFoundError = stderr => {
-  const lines = splitLines(stderr);
-  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
-  const message = lines[messageIndex];
-  return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
-  };
-};
-
-const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
-const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
-const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
-const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
-const RE_AT = /^\s+at/;
-const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
-const isUnhelpfulNativeModuleError = stderr => {
-  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
-};
-const isMessageCodeBlockStartIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_START.test(line);
-};
-const isMessageCodeBlockEndIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_END.test(line);
-};
-const getMessageCodeBlock = stderr => {
-  const lines = splitLines(stderr);
-  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
-  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
-  const relevantLines = lines.slice(startIndex, endIndex);
-  const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
-  return relevantMessage;
-};
-const getNativeModuleErrorMessage = stderr => {
-  const message = getMessageCodeBlock(stderr);
-  return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
-  };
-};
-const isModulesSyntaxError = stderr => {
-  if (!stderr) {
-    return false;
-  }
-  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
-};
-const getModuleSyntaxError = () => {
-  return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
-  };
-};
-const isModuleNotFoundError = stderr => {
-  if (!stderr) {
-    return false;
-  }
-  return stderr.includes('ERR_MODULE_NOT_FOUND');
-};
-const isNormalStackLine = line => {
-  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
-};
-const getDetails = lines => {
-  const index = lines.findIndex(isNormalStackLine);
-  if (index === -1) {
-    return {
-      actualMessage: joinLines(lines),
-      rest: []
-    };
-  }
-  let lastIndex = index - 1;
-  while (++lastIndex < lines.length) {
-    if (!isNormalStackLine(lines[lastIndex])) {
-      break;
-    }
-  }
-  return {
-    actualMessage: lines[index - 1],
-    rest: lines.slice(index, lastIndex)
-  };
-};
-const getHelpfulChildProcessError = (stdout, stderr) => {
-  if (isUnhelpfulNativeModuleError(stderr)) {
-    return getNativeModuleErrorMessage(stderr);
-  }
-  if (isModulesSyntaxError(stderr)) {
-    return getModuleSyntaxError();
-  }
-  if (isModuleNotFoundError(stderr)) {
-    return getModuleNotFoundError(stderr);
-  }
-  const lines = splitLines(stderr);
-  const {
-    actualMessage,
-    rest
-  } = getDetails(lines);
-  return {
-    message: `${actualMessage}`,
-    code: '',
-    stack: rest
-  };
-};
-
-const normalizeLine = line => {
-  if (line.startsWith('Error: ')) {
-    return line.slice('Error: '.length);
-  }
-  if (line.startsWith('VError: ')) {
-    return line.slice('VError: '.length);
-  }
-  return line;
-};
-const getCombinedMessage = (error, message) => {
-  const stringifiedError = normalizeLine(`${error}`);
-  if (message) {
-    return `${message}: ${stringifiedError}`;
-  }
-  return stringifiedError;
-};
-const NewLine = '\n';
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
-};
-const mergeStacks = (parent, child) => {
-  if (!child) {
-    return parent;
-  }
-  const parentNewLineIndex = getNewLineIndex(parent);
-  const childNewLineIndex = getNewLineIndex(child);
-  if (childNewLineIndex === -1) {
-    return parent;
-  }
-  const parentFirstLine = parent.slice(0, parentNewLineIndex);
-  const childRest = child.slice(childNewLineIndex);
-  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
-  if (parentFirstLine.includes(childFirstLine)) {
-    return parentFirstLine + childRest;
-  }
-  return child;
-};
-class VError extends Error {
-  constructor(error, message) {
-    const combinedMessage = getCombinedMessage(error, message);
-    super(combinedMessage);
-    this.name = 'VError';
-    if (error instanceof Error) {
-      this.stack = mergeStacks(this.stack, error.stack);
-    }
-    if (error.codeFrame) {
-      // @ts-ignore
-      this.codeFrame = error.codeFrame;
-    }
-    if (error.code) {
-      // @ts-ignore
-      this.code = error.code;
-    }
-  }
-}
-
-class IpcError extends VError {
-  // @ts-ignore
-  constructor(betterMessage, stdout = '', stderr = '') {
-    if (stdout || stderr) {
-      // @ts-ignore
-      const {
-        message,
-        code,
-        stack
-      } = getHelpfulChildProcessError(stdout, stderr);
-      const cause = new Error(message);
-      // @ts-ignore
-      cause.code = code;
-      cause.stack = stack;
-      super(cause, betterMessage);
-    } else {
-      super(betterMessage);
-    }
-    // @ts-ignore
-    this.name = 'IpcError';
-    // @ts-ignore
-    this.stdout = stdout;
-    // @ts-ignore
-    this.stderr = stderr;
-  }
-}
-
-// @ts-ignore
-const create$3 = async ({
-  path,
-  argv = [],
-  execArgv = [],
-  name,
-  env = process.env
-}) => {
-  string(path);
-  const actualArgv = ['--ipc-type=electron-utility-process', ...argv];
-  const {
-    utilityProcess
-  } = await import('electron');
-  const childProcess = utilityProcess.fork(path, actualArgv, {
-    execArgv,
-    stdio: 'pipe',
-    serviceName: name,
-    env
-  });
-  const handleExit = () => {
-    // @ts-ignore
-    childProcess.stdout.unpipe(process.stdout);
-    // @ts-ignore
-    childProcess.stderr.unpipe(process.stderr);
-  };
-  childProcess.once('exit', handleExit);
-  // @ts-ignore
-  childProcess.stdout.pipe(process.stdout);
-  const {
-    type,
-    stdout,
-    stderr
-  } = await getFirstUtilityProcessEvent(childProcess);
-  if (type === Exit) {
-    throw new IpcError(`Utility process exited before ipc connection was established`, stdout, stderr);
-  }
-  // @ts-ignore
-  childProcess.stderr.pipe(process.stderr);
-  return childProcess;
-};
-class IpcParentWithElectronUtilityProcess extends Ipc {
-  getData(data) {
-    return data;
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const {
-      newValue,
-      transfer
-    } = fixElectronParameters(message);
-    this._rawIpc.postMessage(newValue, transfer);
-  }
-  dispose() {
-    this._rawIpc.kill();
-  }
-  onClose(callback) {
-    this._rawIpc.on('exit', callback);
-  }
-  onMessage(callback) {
-    this._rawIpc.on('message', callback);
-  }
-}
-const wrap$3 = process => {
-  return new IpcParentWithElectronUtilityProcess(process);
-};
-
-const IpcParentWithElectronUtilityProcess$1 = {
-  __proto__: null,
-  create: create$3,
-  wrap: wrap$3
-};
-
-class ChildProcessError extends Error {
-  // @ts-ignore
-  constructor(stderr) {
-    // @ts-ignore
-    const {
-      message,
-      code,
-      stack
-    } = getHelpfulChildProcessError('', stderr);
-    super(message || 'child process error');
-    this.name = 'ChildProcessError';
-    if (code) {
-      // @ts-ignore
-      this.code = code;
-    }
-    if (stack) {
-      // @ts-ignore
-      const lines = splitLines(this.stack);
-      const [firstLine, ...stackLines] = lines;
-      const newStackLines = [firstLine, ...stack, ...stackLines];
-      const newStack = joinLines(newStackLines);
-      this.stack = newStack;
-    }
-  }
-}
-
-// workaround for node not supporting transferrable objects
-// as parameters. If the transferrable object is a parameter,
-// it is received as a plain object is received in the receiving process
-const fixNodeChildProcessParameters = value => {
-  const transfer = getTransferrables(value);
-  if (transfer.length === 0) {
-    throw new IpcError('no transferrables found');
-  }
-  const newValue = removeValues(value, transfer);
-  return {
-    newValue,
-    transfer: transfer[0]
-  };
-};
-
-// @ts-ignore
-const getFirstNodeChildProcessEvent = async childProcess => {
-  // @ts-ignore
-  const {
-    type,
-    event,
-    stdout,
-    stderr
-  } = await new Promise((resolve, reject) => {
-    let stderr = '';
-    let stdout = '';
-    // @ts-ignore
-    const cleanup = value => {
-      if (childProcess.stdout && childProcess.stderr) {
-        childProcess.stderr.off('data', handleStdErrData);
-        childProcess.stdout.off('data', handleStdoutData);
-      }
-      childProcess.off('message', handleMessage);
-      childProcess.off('exit', handleExit);
-      childProcess.off('error', handleError);
-      resolve(value);
-    };
-    // @ts-ignore
-    const handleStdErrData = data => {
-      stderr += data;
-    };
-    // @ts-ignore
-    const handleStdoutData = data => {
-      stdout += data;
-    };
-    // @ts-ignore
-    const handleMessage = event => {
-      cleanup({
-        type: Message,
-        event,
-        stdout,
-        stderr
-      });
-    };
-    // @ts-ignore
-    const handleExit = event => {
-      cleanup({
-        type: Exit,
-        event,
-        stdout,
-        stderr
-      });
-    };
-    // @ts-ignore
-    const handleError = event => {
-      cleanup({
-        type: Error$1,
-        event,
-        stdout,
-        stderr
-      });
-    };
-    if (childProcess.stdout && childProcess.stderr) {
-      childProcess.stderr.on('data', handleStdErrData);
-      childProcess.stdout.on('data', handleStdoutData);
-    }
-    childProcess.on('message', handleMessage);
-    childProcess.on('exit', handleExit);
-    childProcess.on('error', handleError);
-  });
-  return {
-    type,
-    event,
-    stdout,
-    stderr
-  };
-};
-
-// @ts-ignore
-const create$2 = async ({
-  path,
-  argv = [],
-  env,
-  execArgv = [],
-  stdio = 'inherit',
-  name = 'child process'
-}) => {
-  try {
-    string(path);
-    const actualArgv = ['--ipc-type=node-forked-process', ...argv];
-    const {
-      fork
-    } = await import('node:child_process');
-    const childProcess = fork(path, actualArgv, {
-      env,
-      execArgv,
-      stdio: 'pipe'
-    });
-    const {
-      type,
-      event,
-      stderr
-    } = await getFirstNodeChildProcessEvent(childProcess);
-    if (type === Exit) {
-      throw new ChildProcessError(stderr);
-    }
-    if (type === Error$1) {
-      throw new Error(`child process had an error ${event}`);
-    }
-    if (stdio === 'inherit' && childProcess.stdout && childProcess.stderr) {
-      childProcess.stdout.pipe(process.stdout);
-      childProcess.stderr.pipe(process.stderr);
-    }
-    return childProcess;
-  } catch (error) {
-    throw new VError(error, `Failed to launch ${name}`);
-  }
-};
-class IpcParentWithNodeForkedProcess extends Ipc {
-  constructor(childProcess) {
-    super(childProcess);
-    this.pid = childProcess.pid;
-  }
-  getData(message) {
-    return message;
-  }
-  send(message) {
-    this._rawIpc.send(message);
-  }
-  sendAndTransfer(message) {
-    const {
-      newValue,
-      transfer
-    } = fixNodeChildProcessParameters(message);
-    this._rawIpc.send(newValue, transfer);
-  }
-  dispose() {
-    this._rawIpc.kill();
-  }
-  onClose(callback) {
-    this._rawIpc.on('close', callback);
-  }
-  onMessage(callback) {
-    this._rawIpc.on('message', callback);
-  }
-}
-const wrap$2 = childProcess => {
-  return new IpcParentWithNodeForkedProcess(childProcess);
-};
-
-const IpcParentWithNodeForkedProcess$1 = {
-  __proto__: null,
-  create: create$2,
-  wrap: wrap$2
-};
-
-const fixNodeWorkerParameters = value => {
-  const transfer = getTransferrables(value);
-  if (transfer.length === 0) {
-    throw new IpcError('no transferrables found');
-  }
-  return {
-    newValue: value,
-    transfer: transfer
-  };
-};
-
-const addListener = (emitter, type, callback) => {
-  if ('addEventListener' in emitter) {
-    emitter.addEventListener(type, callback);
-  } else {
-    emitter.on(type, callback);
-  }
-};
-const removeListener = (emitter, type, callback) => {
-  if ('removeEventListener' in emitter) {
-    emitter.removeEventListener(type, callback);
-  } else {
-    emitter.off(type, callback);
-  }
-};
-const getFirstEvent = (eventEmitter, eventMap) => {
-  const {
-    resolve,
-    promise
-  } = withResolvers();
-  const listenerMap = Object.create(null);
-  const cleanup = value => {
-    for (const event of Object.keys(eventMap)) {
-      removeListener(eventEmitter, event, listenerMap[event]);
-    }
-    resolve(value);
-  };
-  for (const [event, type] of Object.entries(eventMap)) {
-    const listener = event => {
-      cleanup({
-        type,
-        event
-      });
-    };
-    addListener(eventEmitter, event, listener);
-    listenerMap[event] = listener;
-  }
-  return promise;
-};
-
-const getFirstNodeWorkerEvent = worker => {
-  return getFirstEvent(worker, {
-    message: Message,
-    exit: Exit,
-    error: Error$1
-  });
-};
-
-const readyMessage = 'ready';
-
-// @ts-ignore
-const create$1 = async ({
-  path,
-  argv = [],
-  env = process.env,
-  execArgv = []
-}) => {
-  // @ts-ignore
-  string(path);
-  const actualArgv = ['--ipc-type=node-worker', ...argv];
-  const actualEnv = {
-    ...env,
-    ELECTRON_RUN_AS_NODE: '1'
-  };
-  const {
-    Worker
-  } = await import('node:worker_threads');
-  const worker = new Worker(path, {
-    argv: actualArgv,
-    env: actualEnv,
-    execArgv
-  });
-  // @ts-ignore
-  const {
-    type,
-    event
-  } = await getFirstNodeWorkerEvent(worker);
-  if (type === Exit) {
-    throw new IpcError(`Worker exited before ipc connection was established`);
-  }
-  if (type === Error$1) {
-    throw new IpcError(`Worker threw an error before ipc connection was established: ${event}`);
-  }
-  if (event !== readyMessage) {
-    throw new IpcError('unexpected first message from worker');
-  }
-  return worker;
-};
-class IpcParentWithNodeWorker extends Ipc {
-  constructor(worker) {
-    super(worker);
-  }
-  getData(message) {
-    return message;
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const {
-      newValue,
-      transfer
-    } = fixNodeWorkerParameters(message);
-    this._rawIpc.postMessage(newValue, transfer);
-  }
-  dispose() {
-    this._rawIpc.terminate();
-  }
-  onClose(callback) {
-    this._rawIpc.on('exit', callback);
-  }
-  onMessage(callback) {
-    this._rawIpc.on('message', callback);
-  }
-}
-const wrap$1 = worker => {
-  return new IpcParentWithNodeWorker(worker);
-};
-
-const IpcParentWithNodeWorker$1 = {
-  __proto__: null,
-  create: create$1,
-  wrap: wrap$1
-};
-
-const getActualDataElectron = event => {
-  const {
-    data,
-    ports
-  } = event;
-  if (ports.length === 0) {
-    return data;
-  }
-  return {
-    ...data,
-    params: [...ports, ...data.params]
-  };
-};
-
-const create = ({
-  messagePort
-}) => {
-  if (!isMessagePortMain(messagePort)) {
-    throw new IpcError('port must be of type MessagePortMain');
-  }
-  return messagePort;
-};
-const signal = messagePort => {
-  messagePort.start();
-};
-class IpcParentWithElectronMessagePort extends Ipc {
-  constructor(port) {
-    super(port);
-  }
-  getData = getActualDataElectron;
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const {
-      newValue,
-      transfer
-    } = fixElectronParameters(message);
-    this._rawIpc.postMessage(newValue, transfer);
-  }
-  dispose() {
-    this._rawIpc.close();
-  }
-  onMessage(callback) {
-    this._rawIpc.on('message', callback);
-  }
-  onClose(callback) {
-    this._rawIpc.on('close', callback);
-  }
-}
-const wrap = messagePort => {
-  return new IpcParentWithElectronMessagePort(messagePort);
-};
-
-const IpcParentWithElectronMessagePort$1 = {
-  __proto__: null,
-  create,
-  signal,
-  wrap
-};
-
-export { IpcParentWithElectronMessagePort$1 as IpcParentWithElectronMessagePort, IpcParentWithElectronUtilityProcess$1 as IpcParentWithElectronUtilityProcess, IpcParentWithNodeForkedProcess$1 as IpcParentWithNodeForkedProcess, IpcParentWithNodeWorker$1 as IpcParentWithNodeWorker };