@lvce-editor/iframe-worker 5.34.0 → 5.36.0

package/dist/iframeWorkerMain.js

@@ -472,7 +472,7 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$2 = (id, fn) => {
+const set$3 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$2 = id => {
@@ -482,16 +482,16 @@ const remove$1 = id => {
   delete callbacks[id];
 };
 let id = 0;
-const create$3 = () => {
+const create$3$1 = () => {
   return ++id;
 };
 const registerPromise = () => {
-  const id = create$3();
+  const id = create$3$1();
   const {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$2(id, resolve);
+  set$3(id, resolve);
   return {
     id,
     promise
@@ -571,7 +571,8 @@ const splitLines = lines => {
   return lines.split(NewLine);
 };
 const getCurrentStack = () => {
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(2));
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
 const getNewLineIndex = (string, startIndex = undefined) => {
@@ -705,18 +706,18 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1$1 = (message, error) => {
+const create$1$1 = (id, error) => {
   return {
     jsonrpc: Two,
-    id: message.id,
+    id,
     error
   };
 };
-const getErrorResponse = (message, error, preparePrettyError, logError) => {
+const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(message, errorProperty);
+  return create$1$1(id, errorProperty);
 };
 const create$5 = (message, result) => {
   return {
@@ -729,12 +730,27 @@ const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
   return create$5(message, resultProperty);
 };
+const getErrorResponseSimple = (id, error) => {
+  return {
+    jsonrpc: Two,
+    id,
+    error: {
+      code: Custom,
+      // @ts-ignore
+      message: error.message,
+      data: error
+    }
+  };
+};
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
   try {
     const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
     return getSuccessResponse(message, result);
   } catch (error) {
-    return getErrorResponse(message, error, preparePrettyError, logError);
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
+    }
+    return getErrorResponse(message.id, error, preparePrettyError, logError);
   }
 };
 const defaultPreparePrettyError = error => {
@@ -789,7 +805,7 @@ const handleJsonRpcMessage = async (...args) => {
       try {
         ipc.send(response);
       } catch (error) {
-        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
         ipc.send(errorResponse);
       }
       return;
@@ -820,13 +836,19 @@ const send = (transport, method, ...params) => {
   const message = create$4(method, params);
   transport.send(message);
 };
-const invoke$5 = (ipc, method, ...params) => {
+const invoke$6 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer$4 = (ipc, method, ...params) => {
+const invokeAndTransfer$5 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
 const commands = Object.create(null);
 const register$4 = commandMap => {
   Object.assign(commands, commandMap);
@@ -837,7 +859,7 @@ const getCommand = key => {
 const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
-    throw new Error(`command not found ${command}`);
+    throw new CommandNotFoundError(command);
   }
   return fn(...args);
 };
@@ -853,10 +875,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$5(ipc, method, ...params);
+      return invoke$6(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$4(ipc, method, ...params);
+      return invokeAndTransfer$5(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -894,7 +916,7 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$9 = async ({
+const create$e = async ({
   commandMap,
   messagePort,
   isMessagePortOpen
@@ -912,9 +934,9 @@ const create$9 = async ({
 };
 const MessagePortRpcParent = {
   __proto__: null,
-  create: create$9
+  create: create$e
 };
-const create$2 = async ({
+const create$3 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -926,32 +948,396 @@ const create$2 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$2
+  create: create$3
 };
 
-const RendererWorker = 1;
+const DebugWorker = 55;
+const RendererWorker$1 = 1;
 
 const rpcs$1 = Object.create(null);
-const set$1 = (id, rpc) => {
+const set$2 = (id, rpc) => {
   rpcs$1[id] = rpc;
 };
 const get$1 = id => {
   return rpcs$1[id];
 };
 
-const invoke$4 = (method, ...params) => {
-  const rpc = get$1(RendererWorker);
-  return rpc.invoke(method, ...params);
+const create$2 = rpcId => {
+  return {
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get$1(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get$1(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    set(rpc) {
+      set$2(rpcId, rpc);
+    },
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
+    }
+  };
+};
+
+const {
+  invoke: invoke$5,
+  invokeAndTransfer: invokeAndTransfer$4,
+  set: set$1,
+  dispose
+} = create$2(RendererWorker$1);
+const searchFileHtml = async uri => {
+  return invoke$5('ExtensionHost.searchFileWithHtml', uri);
+};
+const getFilePathElectron = async file => {
+  return invoke$5('FileSystemHandle.getFilePathElectron', file);
+};
+const showContextMenu = async (x, y, id, ...args) => {
+  return invoke$5('ContextMenu.show', x, y, id, ...args);
+};
+const getElectronVersion = async () => {
+  return invoke$5('Process.getElectronVersion');
+};
+const applyBulkReplacement = async bulkEdits => {
+  await invoke$5('BulkReplacement.applyBulkReplacement', bulkEdits);
+};
+const setColorTheme = async id => {
+  // @ts-ignore
+  return invoke$5(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+};
+const getNodeVersion = async () => {
+  return invoke$5('Process.getNodeVersion');
+};
+const getChromeVersion = async () => {
+  return invoke$5('Process.getChromeVersion');
 };
-const invokeAndTransfer$3 = (method, ...params) => {
-  const rpc = get$1(RendererWorker);
-  return rpc.invokeAndTransfer(method, ...params);
+const getV8Version = async () => {
+  return invoke$5('Process.getV8Version');
+};
+const getFileHandles = async fileIds => {
+  const files = await invoke$5('FileSystemHandle.getFileHandles', fileIds);
+  return files;
+};
+const setWorkspacePath = async path => {
+  await invoke$5('Workspace.setPath', path);
+};
+const registerWebViewInterceptor = async (id, port) => {
+  await invokeAndTransfer$4('WebView.registerInterceptor', id, port);
+};
+const unregisterWebViewInterceptor = async id => {
+  await invoke$5('WebView.unregisterInterceptor', id);
+};
+const sendMessagePortToEditorWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$4('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+};
+const sendMessagePortToErrorWorker = async (port, rpcId) => {
+  const command = 'Errors.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$4('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
+};
+const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
+  const command = 'Markdown.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$4('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
+};
+const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
+  const command = 'FileSystem.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$4('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+};
+const readFile$1 = async uri => {
+  return invoke$5('FileSystem.readFile', uri);
+};
+const getWebViewSecret = async key => {
+  // @ts-ignore
+  return invoke$5('WebView.getSecret', key);
+};
+const setWebViewPort = async (uid, port, origin, portType) => {
+  return invokeAndTransfer$4('WebView.setPort', uid, port, origin, portType);
+};
+const setFocus = key => {
+  return invoke$5('Focus.setFocus', key);
+};
+const getFileIcon = async options => {
+  return invoke$5('IconTheme.getFileIcon', options);
+};
+const getColorThemeNames = async () => {
+  return invoke$5('ColorTheme.getColorThemeNames');
+};
+const disableExtension = async id => {
+  // @ts-ignore
+  return invoke$5('ExtensionManagement.disable', id);
+};
+const enableExtension = async id => {
+  // @ts-ignore
+  return invoke$5('ExtensionManagement.enable', id);
+};
+const handleDebugChange = async params => {
+  // @ts-ignore
+  return invoke$5('Run And Debug.handleChange', params);
+};
+const getFolderIcon = async options => {
+  return invoke$5('IconTheme.getFolderIcon', options);
+};
+const closeWidget = async widgetId => {
+  return invoke$5('Viewlet.closeWidget', widgetId);
+};
+const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer$4('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+const sendMessagePortToSearchProcess = async port => {
+  await invokeAndTransfer$4('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+};
+const confirm = async (message, options) => {
+  // @ts-ignore
+  const result = await invoke$5('ConfirmPrompt.prompt', message, options);
+  return result;
+};
+const getRecentlyOpened = async () => {
+  return invoke$5(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+};
+const getKeyBindings = async () => {
+  return invoke$5('KeyBindingsInitial.getKeyBindings');
+};
+const writeClipBoardText = async text => {
+  await invoke$5('ClipBoard.writeText', /* text */text);
+};
+const writeClipBoardImage = async blob => {
+  // @ts-ignore
+  await invoke$5('ClipBoard.writeImage', /* text */blob);
+};
+const searchFileMemory = async uri => {
+  // @ts-ignore
+  return invoke$5('ExtensionHost.searchFileWithMemory', uri);
+};
+const searchFileFetch = async uri => {
+  return invoke$5('ExtensionHost.searchFileWithFetch', uri);
+};
+const showMessageBox = async options => {
+  return invoke$5('ElectronDialog.showMessageBox', options);
+};
+const handleDebugResumed = async params => {
+  await invoke$5('Run And Debug.handleResumed', params);
+};
+const openWidget = async name => {
+  await invoke$5('Viewlet.openWidget', name);
+};
+const getIcons = async requests => {
+  const icons = await invoke$5('IconTheme.getIcons', requests);
+  return icons;
+};
+const activateByEvent = event => {
+  return invoke$5('ExtensionHostManagement.activateByEvent', event);
+};
+const setAdditionalFocus = focusKey => {
+  // @ts-ignore
+  return invoke$5('Focus.setAdditionalFocus', focusKey);
+};
+const getActiveEditorId = () => {
+  // @ts-ignore
+  return invoke$5('GetActiveEditor.getActiveEditorId');
+};
+const getWorkspacePath = () => {
+  return invoke$5('Workspace.getPath');
+};
+const sendMessagePortToRendererProcess = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$4('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
+};
+const getPreference = async key => {
+  return await invoke$5('Preferences.get', key);
+};
+const getAllExtensions = async () => {
+  return invoke$5('ExtensionManagement.getAllExtensions');
+};
+const rerenderEditor = async key => {
+  // @ts-ignore
+  return invoke$5('Editor.rerender', key);
+};
+const handleDebugPaused = async params => {
+  await invoke$5('Run And Debug.handlePaused', params);
+};
+const openUri = async (uri, focus, options) => {
+  await invoke$5('Main.openUri', uri, focus, options);
+};
+const sendMessagePortToSyntaxHighlightingWorker = async port => {
+  await invokeAndTransfer$4(
+  // @ts-ignore
+  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
 };
+const handleDebugScriptParsed = async script => {
+  await invoke$5('Run And Debug.handleScriptParsed', script);
+};
+const getWindowId = async () => {
+  return invoke$5('GetWindowId.getWindowId');
+};
+const getBlob = async uri => {
+  // @ts-ignore
+  return invoke$5('FileSystem.getBlob', uri);
+};
+const getExtensionCommands = async () => {
+  return invoke$5('ExtensionHost.getCommands');
+};
+const showErrorDialog = async errorInfo => {
+  // @ts-ignore
+  await invoke$5('ErrorHandling.showErrorDialog', errorInfo);
+};
+const getFolderSize = async uri => {
+  // @ts-ignore
+  return await invoke$5('FileSystem.getFolderSize', uri);
+};
+const getExtension = async id => {
+  // @ts-ignore
+  return invoke$5('ExtensionManagement.getExtension', id);
+};
+const getMarkdownDom = async html => {
+  // @ts-ignore
+  return invoke$5('Markdown.getVirtualDom', html);
+};
+const renderMarkdown = async (markdown, options) => {
+  // @ts-ignore
+  return invoke$5('Markdown.renderMarkdown', markdown, options);
+};
+const openNativeFolder = async uri => {
+  // @ts-ignore
+  await invoke$5('OpenNativeFolder.openNativeFolder', uri);
+};
+const uninstallExtension = async id => {
+  return invoke$5('ExtensionManagement.uninstall', id);
+};
+const installExtension = async id => {
+  // @ts-ignore
+  return invoke$5('ExtensionManagement.install', id);
+};
+const openExtensionSearch = async () => {
+  // @ts-ignore
+  return invoke$5('SideBar.openViewlet', 'Extensions');
+};
+const setExtensionsSearchValue = async searchValue => {
+  // @ts-ignore
+  return invoke$5('Extensions.handleInput', searchValue);
+};
+const openExternal = async uri => {
+  // @ts-ignore
+  await invoke$5('Open.openExternal', uri);
+};
+const openUrl = async uri => {
+  // @ts-ignore
+  await invoke$5('Open.openUrl', uri);
+};
+const getAllPreferences = async () => {
+  // @ts-ignore
+  return invoke$5('Preferences.getAll');
+};
+const showSaveFilePicker = async () => {
+  // @ts-ignore
+  return invoke$5('FilePicker.showSaveFilePicker');
+};
+const getLogsDir = async () => {
+  // @ts-ignore
+  return invoke$5('PlatformPaths.getLogsDir');
+};
+
+const RendererWorker = {
+  __proto__: null,
+  activateByEvent,
+  applyBulkReplacement,
+  closeWidget,
+  confirm,
+  disableExtension,
+  dispose,
+  enableExtension,
+  getActiveEditorId,
+  getAllExtensions,
+  getAllPreferences,
+  getBlob,
+  getChromeVersion,
+  getColorThemeNames,
+  getElectronVersion,
+  getExtension,
+  getExtensionCommands,
+  getFileHandles,
+  getFileIcon,
+  getFilePathElectron,
+  getFolderIcon,
+  getFolderSize,
+  getIcons,
+  getKeyBindings,
+  getLogsDir,
+  getMarkdownDom,
+  getNodeVersion,
+  getPreference,
+  getRecentlyOpened,
+  getV8Version,
+  getWebViewSecret,
+  getWindowId,
+  getWorkspacePath,
+  handleDebugChange,
+  handleDebugPaused,
+  handleDebugResumed,
+  handleDebugScriptParsed,
+  installExtension,
+  invoke: invoke$5,
+  invokeAndTransfer: invokeAndTransfer$4,
+  openExtensionSearch,
+  openExternal,
+  openNativeFolder,
+  openUri,
+  openUrl,
+  openWidget,
+  readFile: readFile$1,
+  registerWebViewInterceptor,
+  renderMarkdown,
+  rerenderEditor,
+  searchFileFetch,
+  searchFileHtml,
+  searchFileMemory,
+  sendMessagePortToEditorWorker,
+  sendMessagePortToErrorWorker,
+  sendMessagePortToExtensionHostWorker,
+  sendMessagePortToFileSystemWorker,
+  sendMessagePortToMarkdownWorker,
+  sendMessagePortToRendererProcess,
+  sendMessagePortToSearchProcess,
+  sendMessagePortToSyntaxHighlightingWorker,
+  set: set$1,
+  setAdditionalFocus,
+  setColorTheme,
+  setExtensionsSearchValue,
+  setFocus,
+  setWebViewPort,
+  setWorkspacePath,
+  showContextMenu,
+  showErrorDialog,
+  showMessageBox,
+  showSaveFilePicker,
+  uninstallExtension,
+  unregisterWebViewInterceptor,
+  writeClipBoardImage,
+  writeClipBoardText
+};
+
+const {
+  invoke: invoke$4,
+  invokeAndTransfer: invokeAndTransfer$3
+} = RendererWorker;
 
 const invoke$3 = async (method, ...params) => {
+  // @ts-ignore
   return invoke$4('WebView.compatExtensionHostWorkerInvoke', method, ...params);
 };
 const invokeAndTransfer$2 = async (method, ...params) => {
+  // @ts-ignore
   return invokeAndTransfer$3('WebView.compatExtensionHostWorkerInvokeAndTransfer', method, ...params);
 };
 
@@ -1011,19 +1397,18 @@ const getWebViewHtml = (baseUrl, locationOrigin, elements, assetDir) => {
   if (!elements) {
     return '';
   }
-  const middle = [];
-  middle.push('<meta charset="utf-8">');
+  const middle = ['<meta charset="utf-8">'];
   for (const element of elements) {
     switch (element.type) {
-      case 'title':
-        middle.push(`<title>${element.value}</title>`);
+      case 'css':
+        middle.push(`<link rel="stylesheet" href="${locationOrigin}${baseUrl}/${element.path}" />`);
         break;
       case 'script':
         middle.push(`<script type="module" src="${locationOrigin}${assetDir}/js/preview-injected.js"></script>`);
         middle.push(`<script type="module" src="${locationOrigin}${baseUrl}/${element.path}"></script>`);
         break;
-      case 'css':
-        middle.push(`<link rel="stylesheet" href="${locationOrigin}${baseUrl}/${element.path}" />`);
+      case 'title':
+        middle.push(`<title>${element.value}</title>`);
         break;
     }
   }
@@ -1083,9 +1468,9 @@ const getIframeSrcRemote = (webViews, webViewPort, webViewId, locationProtocol,
   // - load webviews the same as in web using blob urls
   // - load webviews from a pattern like /webviews/:id/:fileName
   return {
+    iframeContent,
     iframeSrc,
-    webViewRoot,
-    iframeContent
+    webViewRoot
   };
 };
 
@@ -1099,8 +1484,8 @@ const getBlobUrl = (content, contentType) => {
 
 const getDefaultBaseUrl = webView => {
   const {
-    remotePath,
-    path
+    path,
+    remotePath
   } = webView;
   if (remotePath) {
     if (remotePath.endsWith('/index.html')) {
@@ -1131,9 +1516,9 @@ const getIframeSrc$1 = (webView, locationOrigin, assetDir) => {
   if (srcHtml) {
     const blobUrl = getBlobUrl(srcHtml, 'text/html');
     return {
+      iframeContent: '',
       iframeSrc: blobUrl,
-      webViewRoot: '',
-      iframeContent: ''
+      webViewRoot: ''
     };
   }
   return undefined;
@@ -1163,6 +1548,7 @@ const getPortTuple = () => {
 };
 
 const getSavedState = async () => {
+  // @ts-ignore
   return invoke$4('WebView.getSavedState');
 };
 
@@ -1232,6 +1618,7 @@ const getIframePermissionPolicy = webView => {
 };
 
 const getWebViews = async () => {
+  // @ts-ignore
   return invoke$4('WebView.getWebViews');
 };
 
@@ -1281,20 +1668,22 @@ const getPort = () => {
 };
 
 const invoke$2 = async (method, ...params) => {
+  // @ts-ignore
   return invoke$4('WebView.compatRendererProcessInvoke', method, ...params);
 };
 const invokeAndTransfer$1 = async (method, ...params) => {
+  // @ts-ignore
   return invokeAndTransfer$3('WebView.compatRendererProcessInvokeAndTransfer', method, ...params);
 };
 
 const WebView = 'lvce-oss-webview';
 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 const setPort = async (uid, port, origin, portType) => {
   await invokeAndTransfer$1('WebView.setPort', uid, port, origin, portType);
 };
 
 const invoke$1 = async (method, ...params) => {
+  // @ts-ignore
   return invoke$4('WebView.compatSharedProcessInvoke', method, ...params);
 };
 
@@ -1338,11 +1727,11 @@ const register$2 = async (previewServerId, webViewPort, frameAncestors, webViewR
   await create(previewServerId, useNewWebViewHandler); // TODO move this up
   await start(previewServerId, webViewPort); // TODO move this up
   await (useNewWebViewHandler ? setInfo2({
-    webViewRoot,
-    webViewId,
     contentSecurityPolicy: csp,
     iframeContent,
-    remotePathPrefix
+    remotePathPrefix,
+    webViewId,
+    webViewRoot
   }) : setHandler(previewServerId, frameAncestors, webViewRoot, csp, iframeContent));
   // TODO make this work in gitpod also
 };
@@ -1353,10 +1742,10 @@ const register$1 = async () => {
 
 const getModule = platform => {
   switch (platform) {
-    case Remote:
-      return register$2;
     case Electron:
       return register$3;
+    case Remote:
+      return register$2;
     default:
       return register$1;
   }
@@ -1368,14 +1757,14 @@ const register = async (previewServerId, webViewPort, frameAncestors, webViewRoo
 };
 
 const create2 = async ({
+  assetDir = '',
   id,
-  webViewPort,
-  webViewId,
+  isGitpod,
+  platform,
   previewServerId,
   uri,
-  platform,
-  isGitpod,
-  assetDir = '',
+  webViewId,
+  webViewPort,
   webViewScheme = WebView
 }) => {
   let root = '';
@@ -1394,9 +1783,9 @@ const create2 = async ({
 
   // TODO move all of this to iframe worker
   const {
+    iframeContent,
     iframeSrc,
-    webViewRoot,
-    iframeContent
+    webViewRoot
   } = iframeResult;
   const frameAncestors = getWebViewFrameAncestors(locationProtocol, locationHost);
   const frameTitle = getWebViewTitle(webView);
@@ -1433,11 +1822,11 @@ const create2 = async ({
   const savedState = await getSavedWebViewState(webViewId);
   await invoke$3('ExtensionHostWebView.load', webViewId, savedState);
   return {
+    csp: iframeCsp,
     iframeSrc,
-    sandbox,
-    portId,
     origin,
-    csp: iframeCsp
+    portId,
+    sandbox
   };
 };
 
@@ -1451,13 +1840,14 @@ const createAndLoadWebView = async (id, iframeSrc, sandbox, iframeCsp, credentia
 };
 
 const invoke = async (method, ...params) => {
+  // @ts-ignore
   return invoke$4('WebView.compatRendererWorkerInvoke', method, ...params);
 };
 const invokeAndTransfer = async (method, ...params) => {
+  // @ts-ignore
   return invokeAndTransfer$3('WebView.compatRendererWorkerInvokeAndTransfer', method, ...params);
 };
 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 const createSecondaryWebViewConnection = async (uid, origin, port) => {
   const portType = 'application';
   await invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
@@ -1469,9 +1859,9 @@ const createWebViewConnection = async (uid, origin) => {
     port2
   } = getPortTuple();
   const rpcPromise = MessagePortRpcParent.create({
-    messagePort: port2,
+    commandMap: {},
     isMessagePortOpen: false,
-    commandMap: {}
+    messagePort: port2
   });
   const portType = 'test';
   await invokeAndTransfer('WebView.setPort', uid, port1, origin, portType);
@@ -1580,8 +1970,8 @@ const getWebViewWorkerRpc2 = async rpcInfo => {
   } = getPortTuple();
   const rpcPromise = MessagePortRpcParent.create({
     commandMap: commandMap$1,
-    messagePort: port2,
-    isMessagePortOpen: true
+    isMessagePortOpen: true,
+    messagePort: port2
   });
   // TODO
   // 1. ask extension host worker to ask renderer worker to ask renderer process to create a worker with given url
@@ -1608,8 +1998,6 @@ const getWebViewWorkerRpc2 = async rpcInfo => {
 // compared to direct connections
 
 const interceptors = Object.create(null);
-
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 const add = (id, port) => {
   interceptors[id] = port;
 };
@@ -1638,7 +2026,6 @@ const notifyInterceptors = message => {
   }
 };
 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 const proxyPorts = (port1, port2) => {
   port1.addEventListener('message', event => {
     port2.postMessage(event.data);
@@ -1651,11 +2038,11 @@ const proxyPorts = (port1, port2) => {
 const createWebWorkerRpc2 = async (rpcInfo, webView, savedState, uri, portId, webViewUid, origin) => {
   const rpc = await getWebViewWorkerRpc2(rpcInfo);
   const webViewInfo = {
+    origin,
+    portId: portId,
     rpc,
     webViewId: webView.id,
-    portId: portId,
-    webViewUid,
-    origin
+    webViewUid
   };
   set(portId, webViewInfo);
 
@@ -1685,8 +2072,8 @@ const createWebWorkerRpc2 = async (rpcInfo, webView, savedState, uri, portId, we
   await rpc.invoke('_WebView.create', {
     id: portId,
     savedState,
-    webViewId: webView.id,
-    uri
+    uri,
+    webViewId: webView.id
   });
 };
 
@@ -1700,8 +2087,8 @@ const getWebViewWorkerRpc = async rpcInfo => {
   } = getPortTuple();
   const rpcPromise = MessagePortRpcParent.create({
     commandMap: commandMap$1,
-    messagePort: port2,
-    isMessagePortOpen: true
+    isMessagePortOpen: true,
+    messagePort: port2
   });
   await invokeAndTransfer$2('WebView.createWebViewWorkerRpc', rpcInfo, port1);
   const rpc = await rpcPromise;
@@ -1715,11 +2102,11 @@ const createWebViewRpc$1 = async (rpcInfo, webView, savedState, uri, portId, web
   // eslint-disable-next-line @typescript-eslint/no-deprecated
   const rpc = await getWebViewWorkerRpc(rpcInfo);
   const webViewInfo = {
+    origin,
+    portId: portId,
     rpc,
     webViewId: webView.id,
-    portId: portId,
-    webViewUid,
-    origin
+    webViewUid
   };
   set(portId, webViewInfo);
   await rpc.invoke('LoadFile.loadFile', rpcInfo.url);
@@ -1735,8 +2122,8 @@ const createWebViewRpc$1 = async (rpcInfo, webView, savedState, uri, portId, web
   await rpc.invoke('_WebView.create', {
     id: portId,
     savedState,
-    webViewId: webView.id,
-    uri
+    uri,
+    webViewId: webView.id
   });
 };
 
@@ -1784,13 +2171,13 @@ const getWebViewPort = (platform, locationPort) => {
 };
 
 const create3 = async ({
+  assetDir,
   id,
-  uri,
   isGitpod,
   platform,
-  assetDir,
-  webViewScheme,
-  useNewWebViewHandler
+  uri,
+  useNewWebViewHandler,
+  webViewScheme
 }) => {
   setPlatform(platform);
   let root = '';
@@ -1811,9 +2198,9 @@ const create3 = async ({
   }
   const webView = getWebView(webViews, webViewId);
   const {
+    iframeContent,
     iframeSrc,
-    webViewRoot,
-    iframeContent
+    webViewRoot
   } = iframeResult;
   const frameAncestors = getWebViewFrameAncestors(locationProtocol, locationHost);
   const frameTitle = getWebViewTitle(webView);
@@ -1853,15 +2240,16 @@ const create3 = async ({
   }
   await createWebViewRpc(webView, savedState, uri, portId, id, origin);
   return {
+    csp: iframeCsp,
     iframeSrc,
-    sandbox,
-    portId,
     origin,
-    csp: iframeCsp
+    portId,
+    sandbox
   };
 };
 
 const executeCommand = (method, ...params) => {
+  // @ts-ignore
   return invoke$4('ExecuteExternalCommand.executeExternalCommand', method, ...params);
 };
 
@@ -1874,8 +2262,8 @@ const getWebViewInfo = webViewId => {
   for (const value of Object.values(rpcs)) {
     if (value.webViewId === webViewId) {
       return {
-        uid: value.webViewUid,
-        origin: value.origin
+        origin: value.origin,
+        uid: value.webViewUid
       };
     }
   }
@@ -1900,7 +2288,6 @@ const saveState = async () => {
   return serialized;
 };
 
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 const registerInterceptor = async (id, port) => {
   add(id, port);
 };
@@ -1911,19 +2298,19 @@ const unregisterInterceptor = async id => {
 const commandMap = {
   'WebView.create2': create2,
   'WebView.create3': create3,
-  'WebView.saveState': saveState,
+  'WebView.executeExternalCommand': executeCommand,
   'WebView.getSecret': getSecret,
   'WebView.getWebViewInfo': getWebViewInfo,
   'WebView.registerInterceptor': registerInterceptor,
-  'WebView.unregisterInterceptor': unregisterInterceptor,
-  'WebView.executeExternalCommand': executeCommand
+  'WebView.saveState': saveState,
+  'WebView.unregisterInterceptor': unregisterInterceptor
 };
 
 const listen = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  set$1(RendererWorker, rpc);
+  set$1(rpc);
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/iframe-worker",
-  "version": "5.34.0",
+  "version": "5.36.0",
   "description": "Web Worker to manage creation and lifecycle of iframes in Lvce Editor",
   "keywords": [
     "iframe"