@lvce-editor/iframe-worker 6.3.0 → 6.5.0

package/dist/iframeWorkerMain.js

@@ -61,7 +61,7 @@ class AssertionError extends Error {
   }
 }
 const Object$1 = 1;
-const Number = 2;
+const Number$1 = 2;
 const Array$1 = 3;
 const String = 4;
 const Boolean = 5;
@@ -71,7 +71,7 @@ const Unknown = 8;
 const getType = value => {
   switch (typeof value) {
     case 'number':
-      return Number;
+      return Number$1;
     case 'function':
       return Function;
     case 'string':
@@ -98,10 +98,16 @@ const object = value => {
 };
 const number = value => {
   const type = getType(value);
-  if (type !== Number) {
+  if (type !== Number$1) {
     throw new AssertionError('expected value to be of type number');
   }
 };
+const string = value => {
+  const type = getType(value);
+  if (type !== String) {
+    throw new AssertionError('expected value to be of type string');
+  }
+};
 
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
@@ -231,8 +237,8 @@ const getModuleNotFoundError = stderr => {
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
 };
 const isModuleNotFoundError = stderr => {
@@ -255,14 +261,14 @@ const isUnhelpfulNativeModuleError = stderr => {
 const getNativeModuleErrorMessage = stderr => {
   const message = getMessageCodeBlock(stderr);
   return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
   };
 };
 const getModuleSyntaxError = () => {
   return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
   };
 };
 const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -281,8 +287,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -292,8 +298,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -354,8 +360,8 @@ const wrap$f = global => {
 };
 const waitForFirstMessage = async port => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   port.addEventListener('message', resolve, {
     once: true
@@ -375,8 +381,8 @@ const listen$6 = async () => {
   const type = firstMessage.params[0];
   if (type === 'message-port') {
     parentIpc.send({
-      jsonrpc: '2.0',
       id: firstMessage.id,
+      jsonrpc: '2.0',
       result: null
     });
     parentIpc.dispose();
@@ -433,8 +439,8 @@ const removeListener = (emitter, type, callback) => {
 };
 const getFirstEvent = (eventEmitter, eventMap) => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   const listenerMap = Object.create(null);
   const cleanup = value => {
@@ -446,8 +452,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   for (const [event, type] of Object.entries(eventMap)) {
     const listener = event => {
       cleanup({
-        type,
-        event
+        event,
+        type
       });
     };
     addListener(eventEmitter, event, listener);
@@ -457,8 +463,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
 };
 const Message$1 = 3;
 const create$5$1 = async ({
-  messagePort,
-  isMessagePortOpen
+  isMessagePortOpen,
+  messagePort
 }) => {
   if (!isMessagePort(messagePort)) {
     throw new IpcError('port must be of type MessagePort');
@@ -471,8 +477,8 @@ const create$5$1 = async ({
   });
   messagePort.start();
   const {
-    type,
-    event
+    event,
+    type
   } = await eventPromise;
   if (type !== Message$1) {
     throw new IpcError('Failed to wait for ipc message');
@@ -512,56 +518,14 @@ const IpcParentWithMessagePort$1 = {
   wrap: wrap$5
 };
 
-const Two = '2.0';
-const create$4$1 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
+const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const set$4 = (id, fn) => {
-  callbacks[id] = fn;
-};
-const get$2 = id => {
+const get$3 = id => {
   return callbacks[id];
 };
-const remove$1 = id => {
+const remove$2 = id => {
   delete callbacks[id];
 };
-let id = 0;
-const create$3$1 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3$1();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$4(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2$1 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
-};
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
@@ -705,14 +669,14 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$2(id);
+  const fn = get$3(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
     return;
   }
   fn(response);
-  remove$1(id);
+  remove$2(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -757,7 +721,7 @@ const getErrorProperty = (error, prettyError) => {
 };
 const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error
   };
@@ -768,20 +732,20 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$7 = (message, result) => {
+const create$6 = (message, result) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id: message.id,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$7(message, resultProperty);
+  return create$6(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error: {
       code: Custom,
@@ -868,29 +832,6 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send = (transport, method, ...params) => {
-  const message = create$4$1(method, params);
-  transport.send(message);
-};
-const invoke$5 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer$3 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -913,24 +854,87 @@ const execute = (command, ...args) => {
   return fn(...args);
 };
 
+const Two = '2.0';
+const create$t = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const create$s = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+let id = 0;
+const create$r = () => {
+  return ++id;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise = map => {
+  const id = create$r();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$s(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
 const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
   const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
     // @ts-ignore
     ipc,
     /**
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$5(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$3(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$t(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
@@ -947,7 +951,7 @@ const logError = () => {
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
   const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
@@ -967,14 +971,14 @@ const listen$1 = async (module, options) => {
 };
 const create$e = async ({
   commandMap,
-  messagePort,
-  isMessagePortOpen
+  isMessagePortOpen,
+  messagePort
 }) => {
   // TODO create a commandMap per rpc instance
   register$4(commandMap);
   const rawIpc = await IpcParentWithMessagePort$1.create({
-    messagePort,
-    isMessagePortOpen
+    isMessagePortOpen,
+    messagePort
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
@@ -987,13 +991,14 @@ const MessagePortRpcParent = {
 };
 const create$5 = async ({
   commandMap,
+  isMessagePortOpen = true,
   messagePort
 }) => {
   // TODO create a commandMap per rpc instance
   register$4(commandMap);
   const rawIpc = await IpcParentWithMessagePort$1.create({
-    messagePort,
-    isMessagePortOpen: true
+    isMessagePortOpen,
+    messagePort
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
@@ -1014,8 +1019,9 @@ const PlainMessagePortRpcParent = {
   __proto__: null,
   create: create$4
 };
-const create$3 = async ({
+const create$3$1 = async ({
   commandMap,
+  isMessagePortOpen,
   send
 }) => {
   const {
@@ -1025,14 +1031,15 @@ const create$3 = async ({
   await send(port1);
   return create$5({
     commandMap,
+    isMessagePortOpen,
     messagePort: port2
   });
 };
 const TransferMessagePortRpcParent = {
   __proto__: null,
-  create: create$3
+  create: create$3$1
 };
-const create$6 = async ({
+const create$2$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1044,7 +1051,7 @@ const create$6 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$6
+  create: create$2$1
 };
 const createMockRpc = ({
   commandMap
@@ -1059,50 +1066,65 @@ const createMockRpc = ({
     return command(...params);
   };
   const mockRpc = {
+    invocations,
     invoke,
-    invokeAndTransfer: invoke,
-    invocations
+    invokeAndTransfer: invoke
   };
   return mockRpc;
 };
 
-const Script = 2;
+const Div = 4;
+const Iframe = 68;
 
-const DebugWorker = 55;
 const ExtensionHostWorker = 44;
 const RendererWorker$1 = 1;
 
+const SetDom2 = 'Viewlet.setDom2';
+
 const rpcs$1 = Object.create(null);
-const set$3 = (id, rpc) => {
-  if (rpcs$1[id]) {
-    throw new Error(`rpc with id ${id} is already registered`);
-  }
+const set$4 = (id, rpc) => {
   rpcs$1[id] = rpc;
 };
-const get$1 = id => {
+const get$2 = id => {
   return rpcs$1[id];
 };
+const remove$1 = id => {
+  delete rpcs$1[id];
+};
 
-const create$2 = rpcId => {
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+const create$3 = rpcId => {
   return {
     async dispose() {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       await rpc.dispose();
     },
     // @ts-ignore
     invoke(method, ...params) {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       // @ts-ignore
       return rpc.invoke(method, ...params);
     },
     // @ts-ignore
     invokeAndTransfer(method, ...params) {
-      const rpc = get$1(rpcId);
+      const rpc = get$2(rpcId);
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
+    registerMockRpc(commandMap) {
+      const mockRpc = createMockRpc({
+        commandMap
+      });
+      set$4(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove$1(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
     set(rpc) {
-      set$3(rpcId, rpc);
+      set$4(rpcId, rpc);
     }
   };
 };
@@ -1110,419 +1132,25 @@ const create$2 = rpcId => {
 const {
   invoke: invoke$4,
   invokeAndTransfer: invokeAndTransfer$2,
-  set: set$2
-} = create$2(ExtensionHostWorker);
+  set: set$3
+} = create$3(ExtensionHostWorker);
 
 const {
-  dispose,
   invoke: invoke$3,
   invokeAndTransfer: invokeAndTransfer$1,
-  set: set$1
-} = create$2(RendererWorker$1);
-const searchFileHtml = async uri => {
-  return invoke$3('ExtensionHost.searchFileWithHtml', uri);
-};
-const getFilePathElectron = async file => {
-  return invoke$3('FileSystemHandle.getFilePathElectron', file);
-};
-/**
- * @deprecated
- */
-const showContextMenu = async (x, y, id, ...args) => {
-  return invoke$3('ContextMenu.show', x, y, id, ...args);
-};
-const showContextMenu2 = async (uid, menuId, x, y, args) => {
-  number(uid);
-  number(menuId);
-  number(x);
-  number(y);
-  // @ts-ignore
-  await invoke$3('ContextMenu.show2', uid, menuId, x, y, args);
-};
-const getElectronVersion = async () => {
-  return invoke$3('Process.getElectronVersion');
-};
-const applyBulkReplacement = async bulkEdits => {
-  await invoke$3('BulkReplacement.applyBulkReplacement', bulkEdits);
-};
-const setColorTheme = async id => {
-  // @ts-ignore
-  return invoke$3(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
-};
-const getNodeVersion = async () => {
-  return invoke$3('Process.getNodeVersion');
-};
-const getChromeVersion = async () => {
-  return invoke$3('Process.getChromeVersion');
-};
-const getV8Version = async () => {
-  return invoke$3('Process.getV8Version');
-};
-const getFileHandles = async fileIds => {
-  const files = await invoke$3('FileSystemHandle.getFileHandles', fileIds);
-  return files;
-};
-const setWorkspacePath = async path => {
-  await invoke$3('Workspace.setPath', path);
-};
-const registerWebViewInterceptor = async (id, port) => {
-  await invokeAndTransfer$1('WebView.registerInterceptor', id, port);
-};
-const unregisterWebViewInterceptor = async id => {
-  await invoke$3('WebView.unregisterInterceptor', id);
-};
-const sendMessagePortToEditorWorker = async (port, rpcId) => {
-  const command = 'HandleMessagePort.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
-};
-const sendMessagePortToErrorWorker = async (port, rpcId) => {
-  const command = 'Errors.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
-};
-const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
-  const command = 'Markdown.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
-};
-const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
-  const command = 'IconTheme.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
-};
-const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
-  const command = 'FileSystem.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
-};
-const readFile$1 = async uri => {
-  return invoke$3('FileSystem.readFile', uri);
-};
-const getWebViewSecret = async key => {
-  // @ts-ignore
-  return invoke$3('WebView.getSecret', key);
-};
-const setWebViewPort = async (uid, port, origin, portType) => {
-  return invokeAndTransfer$1('WebView.setPort', uid, port, origin, portType);
-};
-const setFocus = key => {
-  return invoke$3('Focus.setFocus', key);
-};
-const getFileIcon = async options => {
-  return invoke$3('IconTheme.getFileIcon', options);
-};
-const getColorThemeNames = async () => {
-  return invoke$3('ColorTheme.getColorThemeNames');
-};
-const disableExtension = async id => {
-  // @ts-ignore
-  return invoke$3('ExtensionManagement.disable', id);
-};
-const enableExtension = async id => {
-  // @ts-ignore
-  return invoke$3('ExtensionManagement.enable', id);
-};
-const handleDebugChange = async params => {
-  // @ts-ignore
-  return invoke$3('Run And Debug.handleChange', params);
-};
-const getFolderIcon = async options => {
-  return invoke$3('IconTheme.getFolderIcon', options);
-};
-const handleWorkspaceRefresh = async () => {
-  return invoke$3('Layout.handleWorkspaceRefresh');
-};
-const closeWidget = async widgetId => {
-  return invoke$3('Viewlet.closeWidget', widgetId);
-};
+  set: set$2
+} = create$3(RendererWorker$1);
 const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
   await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
 };
-const sendMessagePortToSearchProcess = async port => {
-  await invokeAndTransfer$1('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
-};
-const confirm = async (message, options) => {
-  // @ts-ignore
-  const result = await invoke$3('ConfirmPrompt.prompt', message, options);
-  return result;
-};
-const getRecentlyOpened = async () => {
-  return invoke$3(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
-};
-const getKeyBindings = async () => {
-  return invoke$3('KeyBindingsInitial.getKeyBindings');
-};
-const writeClipBoardText = async text => {
-  await invoke$3('ClipBoard.writeText', /* text */text);
-};
-const readClipBoardText = async () => {
-  return invoke$3('ClipBoard.readText');
-};
-const writeClipBoardImage = async blob => {
-  // @ts-ignore
-  await invoke$3('ClipBoard.writeImage', /* text */blob);
-};
-const searchFileMemory = async uri => {
-  // @ts-ignore
-  return invoke$3('ExtensionHost.searchFileWithMemory', uri);
-};
-const searchFileFetch = async uri => {
-  return invoke$3('ExtensionHost.searchFileWithFetch', uri);
-};
-const showMessageBox = async options => {
-  return invoke$3('ElectronDialog.showMessageBox', options);
-};
-const handleDebugResumed = async params => {
-  await invoke$3('Run And Debug.handleResumed', params);
-};
-const openWidget = async name => {
-  await invoke$3('Viewlet.openWidget', name);
-};
-const getIcons = async requests => {
-  const icons = await invoke$3('IconTheme.getIcons', requests);
-  return icons;
-};
-const activateByEvent = event => {
-  return invoke$3('ExtensionHostManagement.activateByEvent', event);
-};
-const setAdditionalFocus = focusKey => {
-  // @ts-ignore
-  return invoke$3('Focus.setAdditionalFocus', focusKey);
-};
-const getActiveEditorId = () => {
-  // @ts-ignore
-  return invoke$3('GetActiveEditor.getActiveEditorId');
-};
-const getWorkspacePath = () => {
-  return invoke$3('Workspace.getPath');
-};
-const sendMessagePortToRendererProcess = async port => {
-  const command = 'HandleMessagePort.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
-};
-const sendMessagePortToTextMeasurementWorker = async port => {
-  const command = 'TextMeasurement.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
-};
-const sendMessagePortToSourceControlWorker = async port => {
-  const command = 'SourceControl.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker', port, command, 0);
-};
-const sendMessagePortToSharedProcess = async port => {
-  const command = 'HandleElectronMessagePort.handleElectronMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, 0);
-};
-const sendMessagePortToFileSystemProcess = async (port, rpcId) => {
-  const command = 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess';
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, rpcId);
-};
-const sendMessagePortToIframeWorker = async (port, rpcId) => {
-  const command = 'Iframes.handleMessagePort';
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToIframeWorker', port, command, rpcId);
-};
-const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
-  const command = 'Extensions.handleMessagePort';
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
-};
-const getPreference = async key => {
-  return await invoke$3('Preferences.get', key);
-};
-const getAllExtensions = async () => {
-  return invoke$3('ExtensionManagement.getAllExtensions');
-};
-const rerenderEditor = async key => {
-  // @ts-ignore
-  return invoke$3('Editor.rerender', key);
-};
-const handleDebugPaused = async params => {
-  await invoke$3('Run And Debug.handlePaused', params);
-};
-const openUri = async (uri, focus, options) => {
-  await invoke$3('Main.openUri', uri, focus, options);
-};
-const sendMessagePortToSyntaxHighlightingWorker = async port => {
-  await invokeAndTransfer$1(
-  // @ts-ignore
-  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
-};
-const handleDebugScriptParsed = async script => {
-  await invoke$3('Run And Debug.handleScriptParsed', script);
-};
-const getWindowId = async () => {
-  return invoke$3('GetWindowId.getWindowId');
-};
-const getBlob = async uri => {
-  // @ts-ignore
-  return invoke$3('FileSystem.getBlob', uri);
-};
-const getExtensionCommands = async () => {
-  return invoke$3('ExtensionHost.getCommands');
-};
-const showErrorDialog = async errorInfo => {
-  // @ts-ignore
-  await invoke$3('ErrorHandling.showErrorDialog', errorInfo);
-};
-const getFolderSize = async uri => {
-  // @ts-ignore
-  return await invoke$3('FileSystem.getFolderSize', uri);
-};
-const getExtension = async id => {
-  // @ts-ignore
-  return invoke$3('ExtensionManagement.getExtension', id);
-};
-const getMarkdownDom = async html => {
-  // @ts-ignore
-  return invoke$3('Markdown.getVirtualDom', html);
-};
-const renderMarkdown = async (markdown, options) => {
-  // @ts-ignore
-  return invoke$3('Markdown.renderMarkdown', markdown, options);
-};
-const openNativeFolder = async uri => {
-  // @ts-ignore
-  await invoke$3('OpenNativeFolder.openNativeFolder', uri);
-};
-const uninstallExtension = async id => {
-  return invoke$3('ExtensionManagement.uninstall', id);
-};
-const installExtension = async id => {
-  // @ts-ignore
-  return invoke$3('ExtensionManagement.install', id);
-};
-const openExtensionSearch = async () => {
-  // @ts-ignore
-  return invoke$3('SideBar.openViewlet', 'Extensions');
-};
-const setExtensionsSearchValue = async searchValue => {
-  // @ts-ignore
-  return invoke$3('Extensions.handleInput', searchValue, Script);
-};
-const openExternal = async uri => {
-  // @ts-ignore
-  await invoke$3('Open.openExternal', uri);
-};
-const openUrl = async uri => {
-  // @ts-ignore
-  await invoke$3('Open.openUrl', uri);
-};
-const getAllPreferences = async () => {
-  // @ts-ignore
-  return invoke$3('Preferences.getAll');
-};
-const showSaveFilePicker = async () => {
-  // @ts-ignore
-  return invoke$3('FilePicker.showSaveFilePicker');
-};
-const getLogsDir = async () => {
-  // @ts-ignore
-  return invoke$3('PlatformPaths.getLogsDir');
-};
-const measureTextBlockHeight = async (actualInput, fontFamily, fontSize, lineHeightPx, width) => {
-  return invoke$3(`MeasureTextHeight.measureTextBlockHeight`, actualInput, fontFamily, fontSize, lineHeightPx, width);
-};
-const registerMockRpc = commandMap => {
-  const mockRpc = createMockRpc({
-    commandMap
-  });
-  set$1(mockRpc);
-  return mockRpc;
-};
 
 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,
-  handleWorkspaceRefresh,
-  installExtension,
   invoke: invoke$3,
   invokeAndTransfer: invokeAndTransfer$1,
-  measureTextBlockHeight,
-  openExtensionSearch,
-  openExternal,
-  openNativeFolder,
-  openUri,
-  openUrl,
-  openWidget,
-  readClipBoardText,
-  readFile: readFile$1,
-  registerMockRpc,
-  registerWebViewInterceptor,
-  renderMarkdown,
-  rerenderEditor,
-  searchFileFetch,
-  searchFileHtml,
-  searchFileMemory,
-  sendMessagePortToEditorWorker,
-  sendMessagePortToErrorWorker,
   sendMessagePortToExtensionHostWorker,
-  sendMessagePortToExtensionManagementWorker,
-  sendMessagePortToFileSystemProcess,
-  sendMessagePortToFileSystemWorker,
-  sendMessagePortToIconThemeWorker,
-  sendMessagePortToIframeWorker,
-  sendMessagePortToMarkdownWorker,
-  sendMessagePortToRendererProcess,
-  sendMessagePortToSearchProcess,
-  sendMessagePortToSharedProcess,
-  sendMessagePortToSourceControlWorker,
-  sendMessagePortToSyntaxHighlightingWorker,
-  sendMessagePortToTextMeasurementWorker,
-  set: set$1,
-  setAdditionalFocus,
-  setColorTheme,
-  setExtensionsSearchValue,
-  setFocus,
-  setWebViewPort,
-  setWorkspacePath,
-  showContextMenu,
-  showContextMenu2,
-  showErrorDialog,
-  showMessageBox,
-  showSaveFilePicker,
-  uninstallExtension,
-  unregisterWebViewInterceptor,
-  writeClipBoardImage,
-  writeClipBoardText
+  set: set$2
 };
 
 const getCredentialLess = locationHost => {
@@ -1837,7 +1465,7 @@ const getWebViewTitle = webView => {
 const state = {
   id: 0
 };
-const create$1 = () => {
+const create$2 = () => {
   return ++state.id;
 };
 
@@ -1877,7 +1505,7 @@ const invoke = async (method, ...params) => {
 const registerProtocol = async () => {
   await invoke('WebViewServer.registerProtocol');
 };
-const create = async (previewServerId, useNewWebViewHandler) => {
+const create$1 = async (previewServerId, useNewWebViewHandler) => {
   await invoke('WebViewServer.create', previewServerId, useNewWebViewHandler);
 };
 const start = async (previewServerId, webViewPort) => {
@@ -1895,7 +1523,7 @@ const setHandler = async (previewServerId, frameAncestors, webViewRoot, contentS
 
 const register$3 = async (previewServerId, webViewPort, frameAncestors, webViewRoot, csp, iframeContent, webViewId, remotePathPrefix, useNewWebViewHandler) => {
   await registerProtocol();
-  await create(previewServerId, useNewWebViewHandler); // TODO move this up
+  await create$1(previewServerId, useNewWebViewHandler); // TODO move this up
 
   // TODO send info to electron which domain maps to which webview root.
   // for example, video-preview maps to domain lvce-oss-webview://video-preview
@@ -1911,7 +1539,7 @@ const register$2 = async (previewServerId, webViewPort, frameAncestors, webViewR
   // TODO pass webview root, so that only these resources can be accessed
   // TODO pass csp configuration to server
   // TODO pass coop / coep configuration to server
-  await create(previewServerId, useNewWebViewHandler); // TODO move this up
+  await create$1(previewServerId, useNewWebViewHandler); // TODO move this up
   await start(previewServerId, webViewPort); // TODO move this up
   await (useNewWebViewHandler ? setInfo2({
     contentSecurityPolicy: csp,
@@ -1993,7 +1621,7 @@ const create2 = async ({
     port1,
     port2
   } = getPortTuple();
-  const portId = create$1();
+  const portId = create$2();
   const remotePathPrefix = '/remote';
   await register(previewServerId, webViewPort, frameAncestors, webViewRoot, csp, iframeContent, platform, webViewId, remotePathPrefix);
   await invoke$1('WebView.create', id, iframeSrc, sandbox, iframeCsp, credentialless, permissionPolicyString, frameTitle);
@@ -2079,10 +1707,10 @@ const getProtocol = uri => {
 };
 
 const rpcs = Object.create(null);
-const set = (id, rpc) => {
+const set$1 = (id, rpc) => {
   rpcs[id] = rpc;
 };
-const get = id => {
+const get$1 = id => {
   return rpcs[id];
 };
 const getAll$1 = () => {
@@ -2098,7 +1726,7 @@ const getAll$1 = () => {
 
 const getRemoteUrlForWebView = async options => {
   object(options);
-  const webView = get(options.id);
+  const webView = get$1(options.id);
   object(webView);
   const rpcPromise = createWebViewConnection(webView.webViewUid, webView.origin);
   const blobPromise = invoke$3('FileSystem.getBlob', options.uri);
@@ -2222,7 +1850,7 @@ const createWebWorkerRpc2 = async (rpcInfo, webView, savedState, uri, portId, we
     webViewId: webView.id,
     webViewUid
   };
-  set(portId, webViewInfo);
+  set$1(portId, webViewInfo);
 
   // TODO this connection might not be needed
   await createWebViewConnection(webViewUid, origin);
@@ -2286,7 +1914,7 @@ const createWebViewRpc$1 = async (rpcInfo, webView, savedState, uri, portId, web
     webViewId: webView.id,
     webViewUid
   };
-  set(portId, webViewInfo);
+  set$1(portId, webViewInfo);
   await rpc.invoke('LoadFile.loadFile', rpcInfo.url);
 
   // TODO this connection might not be needed
@@ -2397,7 +2025,7 @@ const create3 = async ({
 
   // TODO remove this
   await invoke$2('ExtensionHostManagement.activateByEvent', `onWebView:${webViewId}`);
-  const portId = create$1();
+  const portId = create$2();
   const remotePathPrefix = '/remote';
   await register(previewServerId, webViewPort, frameAncestors, webViewRoot, csp, iframeContent, platform, webViewId, remotePathPrefix, useNewWebViewHandler);
   await createAndLoadWebView(id, iframeSrc, sandbox, iframeCsp, credentialless, permissionPolicyString, frameTitle);
@@ -2426,6 +2054,137 @@ const create3 = async ({
   };
 };
 
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
+const create = () => {
+  const states = Object.create(null);
+  const commandMapRef = {};
+  return {
+    clear() {
+      for (const key of Object.keys(states)) {
+        delete states[key];
+      }
+    },
+    diff(uid, modules, numbers) {
+      const {
+        newState,
+        oldState
+      } = states[uid];
+      const diffResult = [];
+      for (let i = 0; i < modules.length; i++) {
+        const fn = modules[i];
+        if (!fn(oldState, newState)) {
+          diffResult.push(numbers[i]);
+        }
+      }
+      return diffResult;
+    },
+    dispose(uid) {
+      delete states[uid];
+    },
+    get(uid) {
+      return states[uid];
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
+    getKeys() {
+      return Object.keys(states).map(key => {
+        return Number.parseInt(key);
+      });
+    },
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
+    },
+    set(uid, oldState, newState) {
+      states[uid] = {
+        newState,
+        oldState
+      };
+    },
+    wrapCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const newerState = await fn(newState, ...args);
+        if (oldState === newerState || newState === newerState) {
+          return;
+        }
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...newerState
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState
+        };
+      };
+      return wrapped;
+    },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    }
+  };
+};
+
+const {
+  diff,
+  get,
+  getCommandIds,
+  set,
+  wrapCommand} = create();
+
+const create4 = (id, uri, x, y, width, height, platform, assetDir) => {
+  number(platform);
+  string(assetDir);
+  const state = {
+    assetDir,
+    credentialless: true,
+    csp: '',
+    height,
+    id,
+    iframeSrc: '',
+    origin: '',
+    platform,
+    portId: 0,
+    previewServerId: 1,
+    sandbox: [],
+    srcDoc: '',
+    uri,
+    webViewScheme: '',
+    width,
+    x: x - 1,
+    y
+  };
+  set(state.id, state, state);
+};
+
+const isEqual = (oldState, newState) => {
+  return oldState === newState;
+};
+
+const RenderItems = 1;
+
+const modules = [isEqual];
+const numbers = [RenderItems];
+
+const diff2 = uid => {
+  return diff(uid, modules, numbers);
+};
+
 const executeCommand = (method, ...params) => {
   // @ts-ignore
   return invoke$2('ExecuteExternalCommand.executeExternalCommand', method, ...params);
@@ -2455,7 +2214,7 @@ const handleMessagePort2 = async (port, rpcId) => {
     messagePort: port
   });
   if (rpcId) {
-    set$3(rpcId, rpc);
+    set$4(rpcId, rpc);
   }
 };
 
@@ -2467,7 +2226,83 @@ const initialize = async platform => {
       await sendMessagePortToExtensionHostWorker(port, 0);
     }
   });
-  set$2(rpc);
+  set$3(rpc);
+};
+
+const loadContent = async (state, savedState) => {
+  // @ts-ignore
+  const {
+    assetDir,
+    id,
+    platform,
+    uri,
+    webViewScheme
+  } = state;
+  await invoke$4('WebView.create3', {
+    assetDir,
+    id,
+    platform,
+    uri,
+    useNewWebViewHandler: true,
+    webViewScheme
+  });
+
+  // TODO get iframe src
+  // TODO load webview props and register protocol
+  return {
+    ...state
+  };
+};
+
+const renderItems = (oldState, newState) => {
+  const {
+    id
+  } = newState;
+  const dom = [{
+    childCount: 1,
+    type: Div
+  }, {
+    childCount: 0,
+    src: 'https://example.com',
+    // @ts-ignore
+    type: Iframe
+  }];
+  return [SetDom2, id, dom];
+};
+
+const getRenderer = diffType => {
+  switch (diffType) {
+    case RenderItems:
+      return renderItems;
+    default:
+      throw new Error('unknown renderer');
+  }
+};
+
+const applyRender = (oldState, newState, diffResult) => {
+  const commands = [];
+  for (const item of diffResult) {
+    const fn = getRenderer(item);
+    const result = fn(oldState, newState);
+    if (result.length > 0) {
+      commands.push(result);
+    }
+  }
+  return commands;
+};
+
+const render2 = (uid, diffResult) => {
+  const {
+    newState,
+    oldState
+  } = get(uid);
+  set(uid, newState, newState);
+  const commands = applyRender(oldState, newState, diffResult);
+  return commands;
+};
+
+const renderEventListeners = () => {
+  return [];
 };
 
 const saveState = async () => {
@@ -2500,19 +2335,29 @@ const commandMap = {
   'Iframes.initialize': initialize,
   'WebView.create2': create2,
   'WebView.create3': create3,
+  'WebView.create4': create4,
+  'WebView.diff2': diff2,
   'WebView.executeExternalCommand': executeCommand,
+  'WebView.getCommandIds': getCommandIds,
   'WebView.getSecret': getSecret,
   'WebView.getWebViewInfo': getWebViewInfo,
+  'WebView.loadContent': wrapCommand(loadContent),
   'WebView.registerInterceptor': registerInterceptor,
+  'WebView.render2': render2,
+  'WebView.renderEventListeners': renderEventListeners,
   'WebView.saveState': saveState,
   'WebView.unregisterInterceptor': unregisterInterceptor
 };
 
-const listen = async () => {
+const initializeRendererWorker = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  set$1(rpc);
+  set$2(rpc);
+};
+
+const listen = async () => {
+  await initializeRendererWorker();
 };
 
 const main = async () => {

package/package.json

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