@lvce-editor/test-worker 1.3.0 → 1.4.0

package/dist/testWorkerMain.js

@@ -134,7 +134,6 @@ const getErrorConstructor = (message, type) => {
   if (type) {
     switch (type) {
       case DomException:
-        // @ts-ignore
         return DOMException;
       case TypeError$1:
         return TypeError;
@@ -159,7 +158,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);
   }
@@ -175,6 +173,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$1 = lines => {
   return lines.join(NewLine$3);
 };
@@ -183,18 +188,11 @@ const Custom = -32001;
 const splitLines$1 = 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$1(splitLines$1(new Error().stack).slice(1));
+  const currentStack = joinLines$1(splitLines$1(new Error().stack || '').slice(1));
   if (error && error.code && error.code === MethodNotFound) {
     const restoredError = new JsonRpcError(error.message);
     const parentStack = getParentStack(error);
@@ -223,7 +221,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);
@@ -253,6 +250,67 @@ const unwrapJsonRpcResult = responseMessage => {
   }
   throw new JsonRpcError('unexpected response message');
 };
+const isMessagePort = 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, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+const walkValue = (value, transferrables) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables);
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables);
+    }
+  }
+};
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue(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 = (message, error) => {
   return {
     jsonrpc: Two,
@@ -305,7 +363,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);
@@ -337,10 +430,33 @@ const invoke$1 = async (ipc, method, ...params) => {
   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(method, params);
+  ipc.sendAndTransfer(message, transfer);
+  const responseMessage = await promise;
+  const result = unwrapJsonRpcResult(responseMessage);
+  return result;
+};
+
 const invoke = (method, ...params) => {
   const ipc = get$1();
   return invoke$1(ipc, method, ...params);
 };
+const invokeAndTransfer = (method, ...params) => {
+  const ipc = get$1();
+  return invokeAndTransfer$1(ipc, method, ...params);
+};
 const listen$4 = ipc => {
   set$1(ipc);
 };
@@ -348,6 +464,7 @@ const listen$4 = ipc => {
 const Rpc = {
   __proto__: null,
   invoke,
+  invokeAndTransfer,
   listen: listen$4
 };
 
@@ -840,13 +957,13 @@ const TestFrameWorkComponentBaseUrl = {
   getBaseUrl
 };
 
-const execute$2 = async (id, ...args) => {
+const execute$3 = async (id, ...args) => {
   return invoke(id, ...args);
 };
 
 const TestFrameWorkComponentCommand = {
   __proto__: null,
-  execute: execute$2
+  execute: execute$3
 };
 
 const selectItem$1 = async text => {
@@ -1405,7 +1522,62 @@ const TestFrameWorkComponentTitleBarMenuBar = {
   toggleMenu
 };
 
+const getPortTuple = () => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
+};
+
+const sendPortToWebView = async (webviewId, port) => {
+  await invokeAndTransfer('Transferrable.transferToRendererProcess', webviewId, port);
+  console.log('did send port to renderer process');
+  // TODO ask renderer process to transfer the port to the webview
+};
+
+const preparePrettyError$1 = error => {
+  return error;
+};
+const logError$1 = () => {
+  // ignore
+};
+const execute$2 = () => {};
+const requiresSocket$1 = () => {
+  return false;
+};
+const createPortIpc = async webViewId => {
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  const firstEventPromise = new Promise(resolve => {
+    port1.onmessage = resolve;
+  });
+  await sendPortToWebView(webViewId, port2);
+  const firstEvent = await firstEventPromise;
+  // @ts-ignore
+  if (firstEvent.data !== 'ready') {
+    throw new Error('unexpected first message');
+  }
+  const handleOtherMessage = async event => {
+    // @ts-ignore
+    await handleJsonRpcMessage(ipc, event.data, resolve, preparePrettyError$1, execute$2, logError$1, requiresSocket$1);
+  };
+  port1.onmessage = handleOtherMessage;
+  const ipc = {
+    send(message) {
+      port1.postMessage(message);
+    }
+  };
+  return ipc;
+};
+
 const fromId = async webViewId => {
+  const ipc = await createPortIpc(webViewId);
   // TODO
   // 1. create messagechannel
   // 2. send one message port to webview
@@ -1413,7 +1585,7 @@ const fromId = async webViewId => {
   // 4. send test commands like locator.toBeVisible to webview
   const webViewRpc = {
     invoke(method, ...params) {
-      console.log('invoke called', method, params);
+      return invoke$1(ipc, method, ...params);
     }
   };
   return {
@@ -1548,14 +1720,14 @@ const handleIpc = ipc => {
   ipc.addEventListener('message', handleMessage);
 };
 
-const MessagePort = 1;
+const MessagePort$1 = 1;
 const ModuleWorker = 2;
 const ReferencePort = 3;
 const ModuleWorkerAndMessagePort = 8;
 const Auto = () => {
   // @ts-ignore
   if (globalThis.acceptPort) {
-    return MessagePort;
+    return MessagePort$1;
   }
   // @ts-ignore
   if (globalThis.acceptReferencePort) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/test-worker",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "",
   "main": "dist/testWorkerMain.js",
   "type": "module",