@lvce-editor/renderer-process 10.35.0 → 10.36.0

package/dist/rendererProcessMain.js

@@ -865,7 +865,7 @@ const getTransfer = value => {
   return transferrables;
 };
 
-const getData$2 = event => {
+const getData$1 = event => {
   // TODO why are some events not instance of message event?
   if (event instanceof MessageEvent) {
     return event.data;
@@ -900,7 +900,7 @@ const launchWorker = async ({
       if (listener) {
         // @ts-ignore
         this.handleMessage = event => {
-          const data = getData$2(event);
+          const data = getData$1(event);
           // @ts-ignore
           listener({
             data,
@@ -2872,10 +2872,6 @@ const state$6 = {
   modules: Object.create(null)
 };
 
-const handleBeforeInstallPrompt = event => {
-  preventDefault(event);
-};
-
 const handleContentSecurityPolicyViolation = event => {
 };
 
@@ -3197,11 +3193,6 @@ const enable = async window => {
   if ('SecurityPolicyViolationEvent' in self) {
     window.addEventListener('securitypolicyviolation', handleContentSecurityPolicyViolation);
   }
-  if (platform === Web) {
-    // disable prompt to download app as pwa
-    // @ts-expect-error
-    window.onbeforeinstallprompt = handleBeforeInstallPrompt;
-  }
 };
 
 const main = async () => {
@@ -3307,6 +3298,12 @@ ${relevant}`;
 
 const Module = 'module';
 
+const getWorkerDisplayName = name => {
+  if (name && name.endsWith('Worker')) {
+    return name;
+  }
+  return `${name} worker`;
+};
 const create$G = async ({
   url,
   name
@@ -3330,7 +3327,8 @@ const create$G = async ({
       if (isErrorEvent(event)) {
         throw new WorkerError(event);
       }
-      throw new Error(`Failed to start ${name} worker`);
+      const displayName = getWorkerDisplayName(name);
+      throw new IpcError$1(`Failed to start ${displayName}`);
   }
   return worker;
 };
@@ -3462,30 +3460,62 @@ const handleIpcOnce = ipc => {
   }
 };
 
-const getData$1 = event => {
-  return event.data;
+const normalizeLine = line => {
+  if (line.startsWith('Error: ')) {
+    return line.slice('Error: '.length);
+  }
+  if (line.startsWith('VError: ')) {
+    return line.slice('VError: '.length);
+  }
+  return line;
 };
-const attachEvents$9 = 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);
+const getCombinedMessage = (error, message) => {
+  const stringifiedError = normalizeLine(`${error}`);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
+  }
+  return stringifiedError;
 };
-class Ipc extends EventTarget {
-  constructor(rawIpc) {
-    super();
-    this._rawIpc = rawIpc;
-    attachEvents$9(this);
+const NewLine$1 = '\n';
+const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$1, 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;
+    }
   }
 }
-const readyMessage = 'ready';
+
 const walkValue = (value, transferrables, isTransferrable) => {
   if (!value) {
     return;
@@ -3572,148 +3602,35 @@ const fixElectronParameters = value => {
     transfer
   };
 };
-const listen$4 = () => {
-  return window;
-};
-const signal$4 = global => {
-  global.postMessage(readyMessage);
-};
-class IpcChildWithElectronWindow extends Ipc {
-  getData(event) {
-    return getData$1(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const {
-      newValue,
-      transfer
-    } = fixElectronParameters(message);
-    this._rawIpc.postMessage(newValue, location.origin, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    const wrapped = event => {
-      const {
-        ports
-      } = event;
-      if (ports.length) {
-        return;
-      }
-      callback(event);
-      this._rawIpc.removeEventListener('message', wrapped);
-    };
-    this._rawIpc.addEventListener('message', wrapped);
-  }
-}
-const wrap$7 = window => {
-  return new IpcChildWithElectronWindow(window);
-};
-const IpcChildWithElectronWindow$1 = {
-  __proto__: null,
-  listen: listen$4,
-  signal: signal$4,
-  wrap: wrap$7
-};
-const listen$3 = ({
-  port
-}) => {
-  return port;
-};
-const signal$3 = port => {
-  port.postMessage(readyMessage);
-};
-class IpcChildWithMessagePort extends Ipc {
-  constructor(port) {
-    super(port);
-  }
-  getData(event) {
-    return getData$1(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-    this._rawIpc.start();
-  }
-}
-const wrap$6 = port => {
-  return new IpcChildWithMessagePort(port);
-};
-const IpcChildWithMessagePort$1 = {
-  __proto__: null,
-  listen: listen$3,
-  signal: signal$3,
-  wrap: wrap$6
-};
-const listen$2 = () => {
-  // @ts-ignore
-  if (typeof WorkerGlobalScope === 'undefined') {
-    throw new TypeError('module is not in web worker scope');
-  }
-  return globalThis;
-};
-const signal$2 = global => {
-  global.postMessage(readyMessage);
+const attachEvents$9 = 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 IpcChildWithModuleWorker extends Ipc {
-  getData(event) {
-    return getData$1(event);
-  }
-  send(message) {
-    // @ts-ignore
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    // @ts-ignore
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents$9(this);
   }
 }
-const wrap$5 = global => {
-  return new IpcChildWithModuleWorker(global);
-};
-const IpcChildWithModuleWorker$1 = {
-  __proto__: null,
-  listen: listen$2,
-  signal: signal$2,
-  wrap: wrap$5
-};
 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 NewLine = '\n';
 const joinLines = lines => {
-  return lines.join(NewLine$1);
+  return lines.join(NewLine);
 };
 const splitLines = lines => {
-  return lines.split(NewLine$1);
+  return lines.split(NewLine);
 };
 const isModuleNotFoundMessage = line => {
   return line.includes('[ERR_MODULE_NOT_FOUND]');
@@ -3818,61 +3735,6 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     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 = '') {
@@ -3899,6 +3761,143 @@ class IpcError extends VError {
     this.stderr = stderr;
   }
 }
+const readyMessage = 'ready';
+const getData$2 = event => {
+  return event.data;
+};
+const listen$9 = () => {
+  return window;
+};
+const signal$9 = global => {
+  global.postMessage(readyMessage);
+};
+class IpcChildWithElectronWindow extends Ipc {
+  getData(event) {
+    return getData$2(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const {
+      newValue,
+      transfer
+    } = fixElectronParameters(message);
+    this._rawIpc.postMessage(newValue, location.origin, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    const wrapped = event => {
+      const {
+        ports
+      } = event;
+      if (ports.length) {
+        return;
+      }
+      callback(event);
+      this._rawIpc.removeEventListener('message', wrapped);
+    };
+    this._rawIpc.addEventListener('message', wrapped);
+  }
+}
+const wrap$g = window => {
+  return new IpcChildWithElectronWindow(window);
+};
+const IpcChildWithElectronWindow$1 = {
+  __proto__: null,
+  listen: listen$9,
+  signal: signal$9,
+  wrap: wrap$g
+};
+const listen$8 = ({
+  port
+}) => {
+  return port;
+};
+const signal$8 = port => {
+  port.postMessage(readyMessage);
+};
+class IpcChildWithMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
+  }
+  getData(event) {
+    return getData$2(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
+  }
+}
+const wrap$f = port => {
+  return new IpcChildWithMessagePort(port);
+};
+const IpcChildWithMessagePort$1 = {
+  __proto__: null,
+  listen: listen$8,
+  signal: signal$8,
+  wrap: wrap$f
+};
+const listen$7 = () => {
+  // @ts-ignore
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
+  }
+  return globalThis;
+};
+const signal$7 = global => {
+  global.postMessage(readyMessage);
+};
+class IpcChildWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData$2(event);
+  }
+  send(message) {
+    // @ts-ignore
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    // @ts-ignore
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap$e = global => {
+  return new IpcChildWithModuleWorker(global);
+};
+const IpcChildWithModuleWorker$1 = {
+  __proto__: null,
+  listen: listen$7,
+  signal: signal$7,
+  wrap: wrap$e
+};
 const withResolvers = () => {
   let _resolve;
   const promise = new Promise(resolve => {
@@ -3921,10 +3920,10 @@ const waitForFirstMessage = async port => {
   // @ts-ignore
   return event.data;
 };
-const listen$1 = async () => {
-  const parentIpcRaw = listen$2();
-  signal$2(parentIpcRaw);
-  const parentIpc = wrap$5(parentIpcRaw);
+const listen$6 = async () => {
+  const parentIpcRaw = listen$7();
+  signal$7(parentIpcRaw);
+  const parentIpc = wrap$e(parentIpcRaw);
   const firstMessage = await waitForFirstMessage(parentIpc);
   if (firstMessage.method !== 'initialize') {
     throw new IpcError('unexpected first message');
@@ -3947,7 +3946,7 @@ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
     super(port);
   }
   getData(event) {
-    return getData$1(event);
+    return getData$2(event);
   }
   send(message) {
     this._rawIpc.postMessage(message);
@@ -3969,13 +3968,13 @@ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
     this._rawIpc.start();
   }
 }
-const wrap$4 = port => {
+const wrap$d = port => {
   return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
 const IpcChildWithModuleWorkerAndMessagePort$1 = {
   __proto__: null,
-  listen: listen$1,
-  wrap: wrap$4
+  listen: listen$6,
+  wrap: wrap$d
 };
 
 // TODO use handleIncomingIpc function
@@ -6545,7 +6544,9 @@ const listen = async ({
 }) => {
   const module = await getModule(method);
   const rawIpc = await module.listen(options);
+  // @ts-ignore
   if (module.signal) {
+    // @ts-ignore
     module.signal(rawIpc);
   }
   const ipc = module.wrap(rawIpc);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/renderer-process",
-  "version": "10.35.0",
+  "version": "10.36.0",
   "description": "",
   "main": "dist/rendererProcessMain.js",
   "type": "module",