@lvce-editor/editor-worker 2.5.0 → 3.0.0

package/dist/editorWorkerMain.js

@@ -1256,7 +1256,6 @@ const getErrorConstructor = (message, type) => {
   if (type) {
     switch (type) {
       case DomException:
-        // @ts-ignore
         return DOMException;
       case TypeError$1:
         return TypeError;
@@ -1281,7 +1280,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);
   }
@@ -1297,6 +1295,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);
 };
@@ -1305,18 +1310,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);
@@ -1345,7 +1343,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);
@@ -1427,7 +1424,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);
@@ -1458,12 +1490,19 @@ const invoke$5 = async (ipc, method, ...params) => {
   const result = unwrapJsonRpcResult(responseMessage);
   return result;
 };
+
+// TODO deprecated old typings,
+// always use automatic transferrable detection
 const invokeAndTransfer$2 = async (ipc, handle, method, ...params) => {
+  if (typeof handle === 'string') {
+    params = [method, ...params];
+    method = handle;
+  }
   const {
     message,
     promise
   } = create$2$1(method, params);
-  ipc.sendAndTransfer(message, handle);
+  ipc.sendAndTransfer(message);
   const responseMessage = await promise;
   const result = unwrapJsonRpcResult(responseMessage);
   return result;
@@ -1567,9 +1606,9 @@ const invoke$4 = (method, ...params) => {
   const ipc = get$4();
   return invoke$5(ipc, method, ...params);
 };
-const invokeAndTransfer$1 = async (transfer, method, ...params) => {
+const invokeAndTransfer$1 = async (method, ...params) => {
   const ipc = get$4();
-  return invokeAndTransfer$2(ipc, transfer, method, ...params);
+  return invokeAndTransfer$2(ipc, method, ...params);
 };
 const listen$8 = ipc => {
   set$4(ipc);
@@ -1578,12 +1617,12 @@ const listen$8 = ipc => {
 const invoke$3 = async (method, ...params) => {
   return invoke$4(method, ...params);
 };
-const invokeAndTransfer = async (transfer, method, ...params) => {
-  return invokeAndTransfer$1(transfer, method, ...params);
+const invokeAndTransfer = async (method, ...params) => {
+  return invokeAndTransfer$1(method, ...params);
 };
 
 const sendMessagePortToExtensionHostWorker = async port => {
-  await invokeAndTransfer([port], 'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, 'HandleMessagePort.handleMessagePort');
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, 'HandleMessagePort.handleMessagePort');
 };
 
 const withResolvers$1 = () => {
@@ -1664,7 +1703,7 @@ const IpcParentWithExtensionHostWorker = {
 };
 
 const sendMessagePortToSyntaxHighlightingWorker = async port => {
-  await invokeAndTransfer([port], 'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort');
+  await invokeAndTransfer('SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort');
 };
 
 const create$3 = async () => {
@@ -1717,7 +1756,7 @@ const IpcParentWithSyntaxHighlightingWorker = {
 };
 
 const sendMessagePortToRendererProcess = async port => {
-  await invokeAndTransfer([port], 'SendMessagePortToRendererProcess.sendMessagePortToRendererProcess', port, 'HandleMessagePort.handleMessagePort');
+  await invokeAndTransfer('SendMessagePortToRendererProcess.sendMessagePortToRendererProcess', port, 'HandleMessagePort.handleMessagePort');
 };
 
 const create$2 = async () => {
@@ -2364,19 +2403,14 @@ const closeCompletion = editor => {
   };
 };
 
-// @ts-ignore
 const state$6 = {
   isComposing: false,
   compositionText: ''
 };
-
-// @ts-ignore
 const compositionStart = (editor, event) => {
   state$6.isComposing = true;
   return editor;
 };
-
-// @ts-ignore
 const getCompositionChanges = (selections, data) => {
   const changes = [];
   for (let i = 0; i < selections.length; i += 4) {
@@ -2401,16 +2435,12 @@ const getCompositionChanges = (selections, data) => {
   }
   return changes;
 };
-
-// @ts-ignore
 const compositionUpdate = (editor, data) => {
   const selections = editor.selections;
   const changes = getCompositionChanges(selections, data);
   state$6.compositionText = data;
   return scheduleDocumentAndCursorsSelections(editor, changes);
 };
-
-// @ts-ignore
 const compositionEnd = (editor, data) => {
   const selections = editor.selections;
   const changes = getCompositionChanges(selections, data);
@@ -3324,7 +3354,7 @@ const goTo = async ({
       endRowIndex: definition.endRowIndex,
       endColumnIndex: definition.endColumnIndex
     };
-    await invoke$3( /* Main.openUri */'Main.openUri', /* uri */uri, /* focus */true, context);
+    await invoke$3(/* Main.openUri */'Main.openUri', /* uri */uri, /* focus */true, context);
     return editor;
   } catch (error) {
     // TODO if editor is already disposed at this point, do nothing
@@ -3449,7 +3479,7 @@ const goToTypeDefinition = (editor, explicit = true) => {
 const Editor = 3;
 
 const handleContextMenu = async (editor, button, x, y) => {
-  await invoke$3( /* ContextMenu.show */'ContextMenu.show', /* x */x, /* y */y, /* id */Editor);
+  await invoke$3(/* ContextMenu.show */'ContextMenu.show', /* x */x, /* y */y, /* id */Editor);
   return editor;
 };
 
@@ -6319,7 +6349,7 @@ const toggleComment = async editor => {
   } catch (error$1) {
     error(error$1);
     // TODO use correct position
-    await editorShowMessage( /* editor */editor, /* rowIndex */0, /* columnIndex */0, /* message */`${error$1}`, /* isError */true);
+    await editorShowMessage(/* editor */editor, /* rowIndex */0, /* columnIndex */0, /* message */`${error$1}`, /* isError */true);
     return editor;
   }
 };
@@ -8782,14 +8812,14 @@ const commandMap = {
 };
 wrapCommands(commandMap);
 
-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) {
@@ -8801,6 +8831,56 @@ const Auto = () => {
 const getData$1 = event => {
   return event.data;
 };
+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 attachEvents = that => {
   const handleMessage = (...args) => {
     const data = that.getData(...args);
@@ -8822,14 +8902,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 {
@@ -8840,7 +8920,8 @@ class IpcChildWithModuleWorker extends Ipc {
     // @ts-ignore
     this._rawIpc.postMessage(message);
   }
-  sendAndTransfer(message, transfer) {
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
     // @ts-ignore
     this._rawIpc.postMessage(message, transfer);
   }
@@ -8854,14 +8935,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';
@@ -8873,6 +8954,18 @@ const joinLines = lines => {
 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 '.*'$/;
@@ -8921,18 +9014,6 @@ const isModuleNotFoundError = stderr => {
   }
   return stderr.includes('ERR_MODULE_NOT_FOUND');
 };
-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 isNormalStackLine = line => {
   return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
 };
@@ -9079,16 +9160,21 @@ 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('unexpected first message');
   }
   const type = firstMessage.params[0];
   if (type === 'message-port') {
+    parentIpc.send({
+      jsonrpc: '2.0',
+      id: firstMessage.id,
+      result: null
+    });
     parentIpc.dispose();
     const port = firstMessage.params[1];
     return port;
@@ -9105,7 +9191,8 @@ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
   send(message) {
     this._rawIpc.postMessage(message);
   }
-  sendAndTransfer(message, transfer) {
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
     this._rawIpc.postMessage(message, transfer);
   }
   dispose() {
@@ -9121,15 +9208,15 @@ 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 listen$4 = ({
+const listen$2 = ({
   port
 }) => {
   return port;
@@ -9147,7 +9234,8 @@ class IpcChildWithMessagePort extends Ipc {
   send(message) {
     this._rawIpc.postMessage(message);
   }
-  sendAndTransfer(message, transfer) {
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
     this._rawIpc.postMessage(message, transfer);
   }
   dispose() {
@@ -9166,7 +9254,7 @@ const wrap$2 = port => {
 };
 const IpcChildWithMessagePort$1 = {
   __proto__: null,
-  listen: listen$4,
+  listen: listen$2,
   signal,
   wrap: wrap$2
 };
@@ -9177,7 +9265,7 @@ const getModule = method => {
       return IpcChildWithModuleWorker$1;
     case ModuleWorkerAndMessagePort:
       return IpcChildWithModuleWorkerAndMessagePort$1;
-    case MessagePort:
+    case MessagePort$1:
       return IpcChildWithMessagePort$1;
     default:
       throw new Error('unexpected ipc type');

package/package.json

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