@lvce-editor/renderer-process 6.13.0 → 7.0.1

package/dist/rendererProcessMain.js

@@ -165,6 +165,7 @@ const getModuleId = commandId => {
     case 'TestFrameWork.showOverlay':
       return TestFrameWork;
     case 'Transferrable.transfer':
+    case 'Transferrable.transferToWebView':
       return Transferrable;
     case 'Viewlet.appendViewlet':
     case 'Viewlet.dispose':
@@ -538,10 +539,10 @@ const number$1 = value => {
 const state$1$1 = {
   callbacks: Object.create(null)
 };
-const set$5 = (id, fn) => {
+const set$6 = (id, fn) => {
   state$1$1.callbacks[id] = fn;
 };
-const get$6 = id => {
+const get$7 = id => {
   return state$1$1.callbacks[id];
 };
 const remove$2 = id => {
@@ -575,7 +576,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = withResolvers$2();
-  set$5(id, resolve);
+  set$6(id, resolve);
   return {
     id,
     promise
@@ -583,7 +584,7 @@ const registerPromise = () => {
 };
 const resolve = (id, args) => {
   number$1(id);
-  const fn = get$6(id);
+  const fn = get$7(id);
   if (!fn) {
     console.log(args);
     warn$1(`callback ${id} may already be disposed`);
@@ -623,7 +624,6 @@ const getErrorConstructor = (message, type) => {
   if (type) {
     switch (type) {
       case DomException:
-        // @ts-ignore
         return DOMException;
       case TypeError$1:
         return TypeError;
@@ -648,7 +648,6 @@ const getErrorConstructor = (message, type) => {
 };
 const constructError = (message, type, name) => {
   const ErrorConstructor = getErrorConstructor(message, type);
-  // @ts-ignore
   if (ErrorConstructor === DOMException && name) {
     return new ErrorConstructor(message, name);
   }
@@ -664,6 +663,13 @@ const constructError = (message, type, name) => {
 const getNewLineIndex$2 = (string, startIndex = undefined) => {
   return string.indexOf(NewLine$3, startIndex);
 };
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine$3 + parentStack;
+  }
+  return parentStack;
+};
 const joinLines$2 = lines => {
   return lines.join(NewLine$3);
 };
@@ -672,18 +678,11 @@ const Custom = -32001;
 const splitLines$2 = lines => {
   return lines.split(NewLine$3);
 };
-const getParentStack = error => {
-  let parentStack = error.stack || error.data || error.message || '';
-  if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine$3 + parentStack;
-  }
-  return parentStack;
-};
 const restoreJsonRpcError = error => {
   if (error && error instanceof Error) {
     return error;
   }
-  const currentStack = joinLines$2(splitLines$2(new Error().stack).slice(1));
+  const currentStack = joinLines$2(splitLines$2(new Error().stack || '').slice(1));
   if (error && error.code && error.code === MethodNotFound) {
     const restoredError = new JsonRpcError(error.message);
     const parentStack = getParentStack(error);
@@ -712,7 +711,6 @@ const restoreJsonRpcError = error => {
       }
     } else {
       if (error.stack) {
-        // TODO accessing stack might be slow
         const lowerStack = restoredError.stack || '';
         // @ts-ignore
         const indexNewLine = getNewLineIndex$2(lowerStack);
@@ -742,6 +740,67 @@ const unwrapJsonRpcResult = responseMessage => {
   }
   throw new JsonRpcError('unexpected response message');
 };
+const isMessagePort$1 = value => {
+  return typeof MessagePort !== 'undefined' && value instanceof MessagePort;
+};
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
+};
+const isMessagePortMain = value => {
+  return isInstanceOf(value, 'MessagePortMain');
+};
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
+};
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
+};
+const transferrables = [isMessagePort$1, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable$1 = value => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+const walkValue$1 = (value, transferrables) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable$1(value)) {
+    transferrables.push(value);
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue$1(item, transferrables);
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue$1(property, transferrables);
+    }
+  }
+};
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue$1(value, transferrables);
+  return transferrables;
+};
+const isSingleTransferrable = value => {
+  return isSocket(value);
+};
+const getTransferrableParams = value => {
+  const transferrables = getTransferrables(value);
+  if (transferrables.length === 0) {
+    return undefined;
+  }
+  if (isSingleTransferrable(transferrables[0])) {
+    return transferrables[0];
+  }
+  return transferrables;
+};
 const create$1$1 = (message, error) => {
   return {
     jsonrpc: Two,
@@ -794,7 +853,42 @@ const getResponse = async (message, ipc, execute, preparePrettyError, logError,
     return getErrorResponse(message, error, preparePrettyError, logError);
   }
 };
-const handleJsonRpcMessage = async (ipc, message, execute, resolve, preparePrettyError, logError, requiresSocket) => {
+const defaultPreparePrettyError = error => {
+  return error;
+};
+const defaultLogError = () => {
+  // ignore
+};
+const defaultRequiresSocket = () => {
+  return false;
+};
+const defaultResolve = resolve;
+const handleJsonRpcMessage = async (...args) => {
+  let message;
+  let ipc;
+  let execute;
+  let preparePrettyError;
+  let logError;
+  let resolve;
+  let requiresSocket;
+  if (args.length === 1) {
+    const arg = args[0];
+    message = arg.message;
+    ipc = arg.ipc;
+    execute = arg.execute;
+    preparePrettyError = arg.preparePrettyError || defaultPreparePrettyError;
+    logError = arg.logError || defaultLogError;
+    requiresSocket = arg.requiresSocket || defaultRequiresSocket;
+    resolve = arg.resolve || defaultResolve;
+  } else {
+    ipc = args[0];
+    message = args[1];
+    execute = args[2];
+    resolve = args[3];
+    preparePrettyError = args[4];
+    logError = args[5];
+    requiresSocket = args[6];
+  }
   if ('id' in message) {
     if ('method' in message) {
       const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
@@ -829,12 +923,21 @@ const invoke$2 = async (ipc, method, ...params) => {
   const result = unwrapJsonRpcResult(responseMessage);
   return result;
 };
+
+// TODO deprecated old typings,
+// always use automatic transferrable detection
 const invokeAndTransfer$1 = async (ipc, handle, method, ...params) => {
+  let transfer = handle;
+  if (typeof handle === 'string') {
+    params = [method, ...params];
+    method = handle;
+    transfer = getTransferrableParams(params);
+  }
   const {
     message,
     promise
   } = create$2$1(method, params);
-  ipc.sendAndTransfer(message, handle);
+  ipc.sendAndTransfer(message, transfer);
   const responseMessage = await promise;
   const result = unwrapJsonRpcResult(responseMessage);
   return result;
@@ -1010,8 +1113,8 @@ const sendAndTransfer = (message, transfer) => {
   // @ts-expect-error
   state$9.ipc.sendAndTransfer(message, transfer);
 };
-const invokeAndTransfer = (method, transfer, ...params) => {
-  return invokeAndTransfer$1(state$9.ipc, transfer, method, ...params);
+const invokeAndTransfer = (method, ...params) => {
+  return invokeAndTransfer$1(state$9.ipc, method, ...params);
 };
 
 const RendererWorker = {
@@ -2415,8 +2518,8 @@ const remove$1 = $Element => {
   }
 };
 
-const set$4 = setComponentUid;
-const get$5 = getComponentUid;
+const set$5 = setComponentUid;
+const get$6 = getComponentUid;
 const fromEvent = getComponentUidFromEvent;
 
 const startTracking$1 = ($Target, pointerId, handlePointerMove, handlePointerUp) => {
@@ -2902,21 +3005,21 @@ const ConfirmPrompt_ipc = {
 const state$5 = {
   styleSheets: Object.create(null)
 };
-const set$3 = (id, sheet) => {
+const set$4 = (id, sheet) => {
   state$5.styleSheets[id] = sheet;
 };
-const get$4 = id => {
+const get$5 = id => {
   return state$5.styleSheets[id];
 };
 
 const addCssStyleSheet = async (id, text) => {
-  const existing = get$4(id);
+  const existing = get$5(id);
   if (existing) {
     await existing.replace(text);
     return;
   }
   const sheet = new CSSStyleSheet({});
-  set$3(id, sheet);
+  set$4(id, sheet);
   await sheet.replace(text);
   document.adoptedStyleSheets.push(sheet);
 };
@@ -3565,25 +3668,21 @@ const Notification_ipc = {
 const state$2 = {
   canvasObjects: Object.create(null)
 };
-const get$3 = id => {
+const get$4 = id => {
   return state$2.canvasObjects[id];
 };
-const set$2 = (canvasId, canvas) => {
+const set$3 = (canvasId, canvas) => {
   state$2.canvasObjects[canvasId] = canvas;
 };
 
-const get$2 = id => {
-  return get$3(id);
+const get$3 = id => {
+  return get$4(id);
 };
-const create$D = (canvasId, callbackId) => {
+const create$D = async (canvasId, objectId) => {
   const canvas = document.createElement('canvas');
   const offscreenCanvas = canvas.transferControlToOffscreen();
-  set$2(canvasId, canvas);
-  sendAndTransfer({
-    jsonrpc: '2.0',
-    id: callbackId,
-    params: [offscreenCanvas]
-  }, [offscreenCanvas]);
+  set$3(canvasId, canvas);
+  await invokeAndTransfer('Transferrable.transfer', objectId, offscreenCanvas);
 };
 
 const name$f = 'OffscreenCanvas';
@@ -3986,26 +4085,26 @@ const Prompt_ipc = {
 };
 
 const screenCaptures = Object.create(null);
-const get$1 = id => {
+const get$2 = id => {
   return screenCaptures[id];
 };
-const set$1 = (id, captureStream) => {
+const set$2 = (id, captureStream) => {
   screenCaptures[id] = captureStream;
 };
 const remove = id => {
   delete screenCaptures[id];
 };
 
-const get = id => {
+const get$1 = id => {
   number(id);
-  return get$1(id);
+  return get$2(id);
 };
 const start = async (id, options) => {
   try {
     number(id);
     object(options);
     const captureStream = await navigator.mediaDevices.getUserMedia(options);
-    set$1(id, captureStream);
+    set$2(id, captureStream);
   } catch (error) {
     throw new VError$1(error, `Failed to start screen capture`);
   }
@@ -4013,7 +4112,7 @@ const start = async (id, options) => {
 const dispose$e = async (id, options) => {
   try {
     number(id);
-    const captureStream = get$1(id);
+    const captureStream = get$2(id);
     for (const track of captureStream.getTracks()) {
       track.stop();
     }
@@ -4555,6 +4654,14 @@ const TestFrameWork_ipc = {
   name: name$9
 };
 
+const webViews = Object.create(null);
+const set$1 = (id, webView) => {
+  webViews[id] = webView;
+};
+const get = id => {
+  return webViews[id];
+};
+
 const objects = Object.create(null);
 const transfer = (objectId, transferable) => {
   objects[objectId] = transferable;
@@ -4565,9 +4672,34 @@ const acquire = objectId => {
   return value;
 };
 
+// TODO transfer port directly instead of storing
+// it for a short time in state
+const transferToWebView = objectId => {
+  const $Iframe = get(1);
+  if (!$Iframe) {
+    throw new Error(`webview not found`);
+  }
+  const {
+    contentWindow
+  } = $Iframe;
+  if (!contentWindow) {
+    throw new Error(`missing content window`);
+  }
+  // TODO use jsonrpc invoke
+  // TODO allow specifying transfer origin from renderer worker
+  // TODO allow specifing method from renderer worker
+  const port = acquire(objectId);
+  contentWindow.postMessage({
+    jsonrpc: '2.0',
+    method: 'handlePort',
+    params: [port]
+  }, '*', [port]);
+};
+
 const name$8 = 'Transferrable';
 const Commands$9 = {
-  transfer: transfer
+  transfer: transfer,
+  transferToWebView: transferToWebView
 };
 
 const Transferrable_ipc = {
@@ -4731,7 +4863,7 @@ const create$C = (id, uid = id) => {
     state$6.instances[id].state.$Viewlet.remove();
   }
   const instanceState = module.create();
-  set$4(instanceState.$Viewlet, uid);
+  set$5(instanceState.$Viewlet, uid);
   if (module.attachEvents) {
     module.attachEvents(instanceState);
   }
@@ -5371,14 +5503,14 @@ class Ipc extends EventTarget {
   }
 }
 const readyMessage = 'ready';
-const listen$3 = () => {
+const listen$4 = () => {
   // @ts-ignore
   if (typeof WorkerGlobalScope === 'undefined') {
     throw new TypeError('module is not in web worker scope');
   }
   return globalThis;
 };
-const signal$2 = global => {
+const signal$3 = global => {
   global.postMessage(readyMessage);
 };
 class IpcChildWithModuleWorker extends Ipc {
@@ -5403,14 +5535,14 @@ class IpcChildWithModuleWorker extends Ipc {
     this._rawIpc.addEventListener('message', callback);
   }
 }
-const wrap$5 = global => {
+const wrap$6 = global => {
   return new IpcChildWithModuleWorker(global);
 };
 const IpcChildWithModuleWorker$1 = {
   __proto__: null,
-  listen: listen$3,
-  signal: signal$2,
-  wrap: wrap$5
+  listen: listen$4,
+  signal: signal$3,
+  wrap: wrap$6
 };
 const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
 const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
@@ -5628,10 +5760,10 @@ const waitForFirstMessage = async port => {
   // @ts-ignore
   return event.data;
 };
-const listen$2 = async () => {
-  const parentIpcRaw = listen$3();
-  signal$2(parentIpcRaw);
-  const parentIpc = wrap$5(parentIpcRaw);
+const listen$3 = async () => {
+  const parentIpcRaw = listen$4();
+  signal$3(parentIpcRaw);
+  const parentIpc = wrap$6(parentIpcRaw);
   const firstMessage = await waitForFirstMessage(parentIpc);
   if (firstMessage.method !== 'initialize') {
     throw new IpcError$1('unexpected first message');
@@ -5670,13 +5802,54 @@ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
     this._rawIpc.start();
   }
 }
-const wrap$4 = port => {
+const wrap$5 = port => {
   return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
 const IpcChildWithModuleWorkerAndMessagePort$1 = {
   __proto__: null,
-  listen: listen$2,
-  wrap: wrap$4
+  listen: listen$3,
+  wrap: wrap$5
+};
+const isTransferrable = value => {
+  return value instanceof MessagePort;
+};
+const walkValue = (value, transferrables) => {
+  if (!value) {
+    return value;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return undefined;
+  }
+  if (Array.isArray(value)) {
+    const newItems = [];
+    for (const item of value) {
+      const newItem = walkValue(item, transferrables);
+      newItems.push(newItem);
+    }
+    return newItems;
+  }
+  if (typeof value === 'object') {
+    const newObject = Object.create(null);
+    for (const [key, property] of Object.entries(value)) {
+      const newValue = walkValue(property, transferrables);
+      newObject[key] = newValue;
+    }
+    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 = [];
+  const newValue = walkValue(value, transfer);
+  return {
+    newValue,
+    transfer
+  };
 };
 const listen$1 = () => {
   return window;
@@ -5691,8 +5864,12 @@ class IpcChildWithWindow extends Ipc {
   send(message) {
     this._rawIpc.postMessage(message);
   }
-  sendAndTransfer(message, transfer) {
-    this._rawIpc.postMessage(message, location.origin, transfer);
+  sendAndTransfer(message, _transfer) {
+    const {
+      newValue,
+      transfer
+    } = fixElectronParameters(message);
+    this._rawIpc.postMessage(newValue, location.origin, transfer);
   }
   dispose() {
     // ignore
@@ -5717,13 +5894,13 @@ class IpcChildWithWindow extends Ipc {
 const wrap$3 = window => {
   return new IpcChildWithWindow(window);
 };
-const IpcChildWithWindow$1 = {
+const IpcChildWithElectronWindow = {
   __proto__: null,
   listen: listen$1,
   signal: signal$1,
   wrap: wrap$3
 };
-const listen$4 = ({
+const listen$2 = ({
   port
 }) => {
   return port;
@@ -5760,7 +5937,7 @@ const wrap$2 = port => {
 };
 const IpcChildWithMessagePort$1 = {
   __proto__: null,
-  listen: listen$4,
+  listen: listen$2,
   signal,
   wrap: wrap$2
 };
@@ -6063,9 +6240,9 @@ const create$x = async ({
   if (!isElectron) {
     throw new Error('Electron api was requested but is not available');
   }
-  const windowIpc = IpcChildWithWindow$1.wrap(window);
+  const windowIpc = IpcChildWithElectronWindow.wrap(window);
   handleIpcOnce(windowIpc);
-  const webContentsIds = await invokeAndTransfer$1(windowIpc, [port], 'CreateMessagePort.createMessagePort', ipcId);
+  const webContentsIds = await invokeAndTransfer$1(windowIpc, 'CreateMessagePort.createMessagePort', ipcId, port);
   return webContentsIds;
 };
 
@@ -9014,7 +9191,7 @@ const getUid = () => {
   if (!$Main) {
     return 0;
   }
-  return get$5($Main);
+  return get$6($Main);
 };
 const handleTabsWheel = event => {
   const uid = getUid();
@@ -9816,7 +9993,7 @@ const setScreenCapture = (state, id) => {
     $Viewlet
   } = state;
   const $Video = document.createElement('video');
-  const screenCapture = get(id);
+  const screenCapture = get$1(id);
   $Video.srcObject = screenCapture;
   $Video.onloadedmetadata = handleLoadedMetaData;
   $Viewlet.append($Video);
@@ -10456,8 +10633,8 @@ const create$4 = () => {
   };
 };
 const setTerminal = (state, canvasCursorId, canvasTextId) => {
-  const canvasText = get$2(canvasTextId);
-  const canvasCursor = get$2(canvasCursorId);
+  const canvasText = get$3(canvasTextId);
+  const canvasCursor = get$3(canvasCursorId);
   const {
     $Viewlet
   } = state;
@@ -10933,7 +11110,7 @@ const setMenus = (state, changes, uid) => {
           const menu = change[1];
           const dom = change[2];
           const $Menu = create$Menu();
-          set$4($Menu, uid);
+          set$5($Menu, uid);
           $Menu.onmouseover = handleMenuMouseOver;
           $Menu.onclick = handleMenuClick;
           const {
@@ -11393,12 +11570,16 @@ const setIframe = (state, src, sandbox = []) => {
   $Iframe.src = src;
   $Parent.append($Iframe);
   state.frame = $Iframe;
+  set$1(1, $Iframe);
 };
 const setPort = (state, portId, origin) => {
   const port = acquire(portId);
   const {
     frame
   } = state;
+  // TODO wait for load in renderer worker
+  // TODO avoid closure
+  // TODO use jsonrpc invoke
   frame.addEventListener('load', () => {
     const {
       contentWindow

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/renderer-process",
-  "version": "6.13.0",
+  "version": "7.0.1",
   "description": "",
   "main": "dist/diffWorkerMain.js",
   "type": "module",