@lvce-editor/hover-worker 2.15.0 → 2.17.0

package/dist/hoverWorkerMain.js

@@ -63,7 +63,7 @@ class AssertionError extends Error {
 const Object$1 = 1;
 const Number$1 = 2;
 const Array$1 = 3;
-const String = 4;
+const String$1 = 4;
 const Boolean$1 = 5;
 const Function = 6;
 const Null = 7;
@@ -75,7 +75,7 @@ const getType = value => {
     case 'function':
       return Function;
     case 'string':
-      return String;
+      return String$1;
     case 'object':
       if (value === null) {
         return Null;
@@ -525,7 +525,7 @@ const register = commandMap => {
 const getCommand$1 = key => {
   return commands[key];
 };
-const execute$1 = (command, ...args) => {
+const execute = (command, ...args) => {
   const fn = getCommand$1(command);
   if (!fn) {
     throw new CommandNotFoundError(command);
@@ -645,6 +645,9 @@ const restoreExistingError = (error, currentStack) => {
 };
 const restoreMethodNotFoundError = (error, currentStack) => {
   const restoredError = new JsonRpcError(error.message);
+  Object.assign(restoredError, {
+    code: error.code
+  });
   const parentStack = getParentStack(error);
   setStack(restoredError, `${parentStack}${NewLine}${currentStack}`);
   return restoredError;
@@ -664,9 +667,13 @@ const applyDataProperties = (restoredError, error) => {
     // @ts-ignore
     restoredError.codeFrame = error.data.codeFrame;
   }
-  if (error.data.code) {
+  if (typeof error.data.code === 'string' || typeof error.data.code === 'number') {
     // @ts-ignore
-    restoredError.code = error.data.code;
+    Object.defineProperty(restoredError, 'code', {
+      configurable: true,
+      value: error.data.code,
+      writable: true
+    });
   }
   if (error.data.type) {
     // @ts-ignore
@@ -687,7 +694,14 @@ const applyDirectProperties = (restoredError, error) => {
   }
 };
 const restoreMessageError = (error, _currentStack) => {
-  const restoredError = constructError(error.message, error.type, error.name);
+  const restoredError = constructError(error.message, error.type || error.data?.type, error.name);
+  if (typeof error.code === 'string' || typeof error.code === 'number') {
+    Object.defineProperty(restoredError, 'code', {
+      configurable: true,
+      value: error.code,
+      writable: true
+    });
+  }
   if (error.data) {
     applyDataProperties(restoredError, error);
   } else {
@@ -695,6 +709,23 @@ const restoreMessageError = (error, _currentStack) => {
   }
   return restoredError;
 };
+const getFallbackMessage = error => {
+  if (error && typeof error.message === 'string' && error.message) {
+    return error.message;
+  }
+  if (error && error.data) {
+    return getFallbackMessage(error.data);
+  }
+  const stringified = String(error);
+  if (stringified !== '[object Object]') {
+    return stringified;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return stringified;
+  }
+};
 const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
@@ -703,13 +734,13 @@ const restoreJsonRpcError = error => {
   if (error && error.code && error.code === MethodNotFound) {
     return restoreMethodNotFoundError(error, currentStack);
   }
+  if (error && error.error) {
+    return restoreJsonRpcError(error.error);
+  }
   if (error && error.message) {
     return restoreMessageError(error);
   }
-  if (typeof error === 'string') {
-    return new Error(`JsonRpc Error: ${error}`);
-  }
-  return new Error(`JsonRpc Error: ${error}`);
+  return new Error(`JsonRpc Error: ${getFallbackMessage(error)}`);
 };
 const unwrapJsonRpcResult = responseMessage => {
   if ('error' in responseMessage) {
@@ -766,9 +797,9 @@ const getErrorProperty = (error, prettyError) => {
   return {
     code: Custom,
     data: {
-      code: prettyError.code,
+      code: prettyError.code ?? error?.code,
       codeFrame: prettyError.codeFrame,
-      name: prettyError.name,
+      name: prettyError.name ?? error?.name,
       stack: getStack(prettyError),
       type: getErrorType(prettyError)
     },
@@ -788,7 +819,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$9 = (message, result) => {
+const create$a = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -797,13 +828,18 @@ const create$9 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$9(message, resultProperty);
+  return create$a(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
     error: {
       code: Custom,
-      data: error,
+      data: error instanceof Error ? {
+        ...error,
+        code: 'code' in error ? error.code : undefined,
+        stack: error.stack,
+        type: error.name
+      } : error,
       // @ts-ignore
       message: error.message
     },
@@ -891,7 +927,7 @@ const handleJsonRpcMessage = async (...args) => {
 
 const Two = '2.0';
 
-const create$8 = (method, params) => {
+const create$9 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -899,7 +935,7 @@ const create$8 = (method, params) => {
   };
 };
 
-const create$7 = (id, method, params) => {
+const create$8 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -910,12 +946,12 @@ const create$7 = (id, method, params) => {
 };
 
 let id = 0;
-const create$6 = () => {
+const create$7 = () => {
   return ++id;
 };
 
 const registerPromise = map => {
-  const id = create$6();
+  const id = create$7();
   const {
     promise,
     resolve
@@ -932,7 +968,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$7(id, method, params);
+  const message = create$8(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -968,7 +1004,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$8(method, params);
+      const message = create$9(method, params);
       ipc.send(message);
     }
   };
@@ -985,8 +1021,11 @@ const logError = () => {
   // handled by renderer worker
 };
 const handleMessage = event => {
+  if (event.data === 'ready') {
+    return Promise.resolve();
+  }
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  const actualExecute = event?.target?.execute || execute$1;
+  const actualExecute = event?.target?.execute || execute;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 
@@ -1008,7 +1047,35 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
-const create$5 = async ({
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
+};
+
+const create$6 = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -1026,7 +1093,7 @@ const create$5 = async ({
   return rpc;
 };
 
-const create$4 = async ({
+const create$5 = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -1036,13 +1103,27 @@ const create$4 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$5({
+  return create$6({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
   });
 };
 
+const create$4 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$5({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
+  });
+};
+
 const create$3 = async ({
   commandMap
 }) => {
@@ -1079,29 +1160,100 @@ const toCommandId = key => {
   return key.slice(dotIndex + 1);
 };
 const create$2 = () => {
+  const commandQueues = new Map();
+  const generations = Object.create(null);
   const states = Object.create(null);
-  const commandMapRef = {};
+  const commandMapRef = Object.create(null);
+  const commandsById = Object.create(null);
+  const getGeneration = uid => generations[uid] || 0;
+  const isCurrentGeneration = (uid, generation) => {
+    return states[uid] !== undefined && getGeneration(uid) === generation;
+  };
+  const updateState = (uid, generation, fallbackState, updater) => {
+    if (!isCurrentGeneration(uid, generation)) {
+      return Promise.resolve(fallbackState);
+    }
+    const current = states[uid];
+    const updatedState = updater(current.newState);
+    if (updatedState !== current.newState) {
+      states[uid] = {
+        newState: updatedState,
+        oldState: current.oldState,
+        scheduledState: updatedState
+      };
+    }
+    return Promise.resolve(updatedState);
+  };
+  const createAsyncCommandContext = (uid, generation) => {
+    let latestState = states[uid].newState;
+    return {
+      getState: () => {
+        if (isCurrentGeneration(uid, generation)) {
+          latestState = states[uid].newState;
+        }
+        return latestState;
+      },
+      updateState: async updater => {
+        latestState = await updateState(uid, generation, latestState, updater);
+        return latestState;
+      }
+    };
+  };
+  const enqueueCommand = async (uid, command) => {
+    const previous = commandQueues.get(uid) || Promise.resolve();
+    const run = async () => {
+      try {
+        await previous;
+      } catch {
+        // The previous caller receives its error; later commands must still run.
+      }
+      await command();
+    };
+    const current = run();
+    commandQueues.set(uid, current);
+    try {
+      await current;
+    } finally {
+      if (commandQueues.get(uid) === current) {
+        commandQueues.delete(uid);
+      }
+    }
+  };
   return {
     clear() {
+      commandQueues.clear();
       for (const key of Object.keys(states)) {
         delete states[key];
       }
     },
+    createDirectEventCommandMap(requestRender) {
+      return {
+        async 'Viewlet.executeViewletCommand'(uid, command, ...args) {
+          const fn = commandsById[command];
+          if (!fn) {
+            throw new Error(`Viewlet command not found: ${command}`);
+          }
+          await fn(uid, ...args);
+          await requestRender(uid);
+        }
+      };
+    },
     diff(uid, modules, numbers) {
       const {
-        newState,
-        oldState
+        oldState,
+        scheduledState
       } = states[uid];
       const diffResult = [];
       for (let i = 0; i < modules.length; i++) {
         const fn = modules[i];
-        if (!fn(oldState, newState)) {
+        if (!fn(oldState, scheduledState)) {
           diffResult.push(numbers[i]);
         }
       }
       return diffResult;
     },
     dispose(uid) {
+      commandQueues.delete(uid);
       delete states[uid];
     },
     get(uid) {
@@ -1113,21 +1265,36 @@ const create$2 = () => {
       return ids;
     },
     getKeys() {
-      return Object.keys(states).map(key => {
-        return Number.parseFloat(key);
-      });
+      return Object.keys(states).map(Number);
     },
     registerCommands(commandMap) {
       Object.assign(commandMapRef, commandMap);
+      for (const [key, fn] of Object.entries(commandMap)) {
+        commandsById[toCommandId(key)] = fn;
+      }
     },
-    set(uid, oldState, newState) {
+    set(uid, oldState, newState, scheduledState) {
+      const current = states[uid];
+      if (!current || oldState === newState && newState !== current.newState) {
+        generations[uid] = getGeneration(uid) + 1;
+      }
       states[uid] = {
         newState,
-        oldState
+        oldState,
+        scheduledState: scheduledState ?? newState
       };
     },
+    wrapAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
+        const context = createAsyncCommandContext(uid, generation);
+        await fn(context, ...args);
+      };
+      return wrapped;
+    },
     wrapCommand(fn) {
       const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
         const {
           newState,
           oldState
@@ -1136,6 +1303,9 @@ const create$2 = () => {
         if (oldState === newerState || newState === newerState) {
           return;
         }
+        if (!isCurrentGeneration(uid, generation)) {
+          return;
+        }
         const latestOld = states[uid];
         const latestNew = {
           ...latestOld.newState,
@@ -1143,7 +1313,8 @@ const create$2 = () => {
         };
         states[uid] = {
           newState: latestNew,
-          oldState: latestOld.oldState
+          oldState: latestOld.oldState,
+          scheduledState: latestNew
         };
       };
       return wrapped;
@@ -1159,6 +1330,7 @@ const create$2 = () => {
     },
     wrapLoadContent(fn) {
       const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
         const {
           newState,
           oldState
@@ -1173,6 +1345,11 @@ const create$2 = () => {
             error
           };
         }
+        if (!isCurrentGeneration(uid, generation)) {
+          return {
+            error
+          };
+        }
         const latestOld = states[uid];
         const latestNew = {
           ...latestOld.newState,
@@ -1180,13 +1357,59 @@ const create$2 = () => {
         };
         states[uid] = {
           newState: latestNew,
-          oldState: latestOld.oldState
+          oldState: latestOld.oldState,
+          scheduledState: latestNew
         };
         return {
           error
         };
       };
       return wrapped;
+    },
+    wrapSerialAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const context = createAsyncCommandContext(uid, generation);
+          await fn(context, ...args);
+        });
+      };
+      return wrapped;
+    },
+    wrapSerialCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const {
+            newState,
+            oldState
+          } = states[uid];
+          const newerState = await fn(newState, ...args);
+          if (oldState === newerState || newState === newerState) {
+            return;
+          }
+          if (!isCurrentGeneration(uid, generation)) {
+            return;
+          }
+          const latestOld = states[uid];
+          const latestNew = {
+            ...latestOld.newState,
+            ...newerState
+          };
+          states[uid] = {
+            newState: latestNew,
+            oldState: latestOld.oldState,
+            scheduledState: latestNew
+          };
+        });
+      };
+      return wrapped;
     }
   };
 };
@@ -1195,7 +1418,7 @@ const terminate = () => {
 };
 
 const rpcs = Object.create(null);
-const set$5 = (id, rpc) => {
+const set$6 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
@@ -1228,7 +1451,7 @@ const create$1 = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$5(rpcId, mockRpc);
+      set$6(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -1237,61 +1460,58 @@ const create$1 = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$5(rpcId, rpc);
+      set$6(rpcId, rpc);
     }
   };
 };
 
 const Text = 12;
 
-const EditorWorker$1 = 99;
+const EditorWorker = 99;
 const ExtensionHostWorker = 44;
+const ExtensionManagementWorker = 9006;
 
 const SetFocusContext = 'Viewlet.setFocusContext';
 
 const {
-  invoke: invoke$3,
+  invoke: invoke$2,
   invokeAndTransfer,
-  set: set$4
-} = create$1(EditorWorker$1);
+  set: set$5
+} = create$1(EditorWorker);
 const sendMessagePortToExtensionManagementWorker$1 = async port => {
   await invokeAndTransfer('SendMessagePortToExtensionManagementWorker.sendMessagePortToExtensionManagementWorker', port, 0);
 };
+const getLines$1 = async editorUid => {
+  const lines = await invoke$2('Editor.getLines2', editorUid);
+  return lines;
+};
 const getWordAtOffset2$1 = async editorUid => {
-  return invoke$3('Editor.getWordAtOffset2', editorUid);
+  return invoke$2('Editor.getWordAtOffset2', editorUid);
 };
 const getWordBefore$1 = async (editorUid, rowIndex, columnIndex) => {
-  return invoke$3('Editor.getWordBefore2', editorUid, rowIndex, columnIndex);
+  return invoke$2('Editor.getWordBefore2', editorUid, rowIndex, columnIndex);
 };
-
-const EditorWorker = {
-  __proto__: null,
-  getWordAtOffset2: getWordAtOffset2$1,
-  getWordBefore: getWordBefore$1,
-  invoke: invoke$3,
-  invokeAndTransfer,
-  sendMessagePortToExtensionManagementWorker: sendMessagePortToExtensionManagementWorker$1,
-  set: set$4
+const getUri$1 = async editorUid => {
+  // @ts-ignore
+  return invoke$2('Editor.getUri', editorUid);
 };
 
 const {
-  invoke: invoke$2,
-  set: set$3
+  set: set$4
 } = create$1(ExtensionHostWorker);
 
-const ExtensionHost = {
-  __proto__: null,
-  invoke: invoke$2,
-  set: set$3
-};
-
 const {
-  getWordAtOffset2,
-  getWordBefore,
   invoke: invoke$1,
-  sendMessagePortToExtensionManagementWorker,
-  set: set$2
-} = EditorWorker;
+  set: set$3
+} = create$1(ExtensionManagementWorker);
+
+const getLines = (...args) => getLines$1(...args);
+const getUri = (...args) => getUri$1(...args);
+const getWordAtOffset2 = (...args) => getWordAtOffset2$1(...args);
+const getWordBefore = (...args) => getWordBefore$1(...args);
+const invoke = (...args) => invoke$2(...args);
+const sendMessagePortToExtensionManagementWorker = (...args) => sendMessagePortToExtensionManagementWorker$1(...args);
+const set$2 = (...args) => set$5(...args);
 
 const FocusEditorHovers = 9;
 const FocusEditorRename = 11;
@@ -1303,7 +1523,7 @@ const close = async state => {
     editorUid
   } = state;
   // @ts-ignore
-  await invoke$1('Editor.closeWidget2', editorUid, Hover, 'Hovers', FocusEditorHovers);
+  await invoke('Editor.closeWidget2', editorUid, Hover, 'Hovers', FocusEditorHovers);
   return state;
 };
 
@@ -1470,7 +1690,7 @@ const sendMessagePortToExtensionHostWorker = async port => {
 
 const createExtensionHostRpc = async () => {
   try {
-    const rpc = await create$4({
+    const rpc = await create$5({
       commandMap: {},
       send: sendMessagePortToExtensionHostWorker
     });
@@ -1480,10 +1700,7 @@ const createExtensionHostRpc = async () => {
   }
 };
 
-const {
-  invoke,
-  set
-} = ExtensionHost;
+const set = (...args) => set$4(...args);
 
 const initialize = async () => {
   const rpc = await createExtensionHostRpc();
@@ -1508,9 +1725,8 @@ const getHoverDetails = async (hover, error, hoverFullWidth, hoverPaddingLeft, h
       lineInfos: []
     };
   }
-  const {
-    documentation
-  } = hover;
+  const hoverText = typeof hover.text === 'string' && hover.text.trim() ? hover.text : '';
+  const documentation = typeof hover.documentation === 'string' && hover.documentation.trim() ? hover.documentation : hoverText;
   const lineInfos = await tokenizeCodeBlock();
   const documentationHeight = await measureTextBlockHeight();
   return {
@@ -1561,52 +1777,28 @@ const getOffsetAtCursor = editorUid => {
 };
 
 const getPositionAtCursor = async editorUid => {
-  const position = await invoke$1('Editor.getPositionAtCursor', editorUid);
+  const position = await invoke('Editor.getPositionAtCursor', editorUid);
   return position;
 };
 
-const OnHover = 'onHover';
-
-const HoverExecute = 'ExtensionHostHover.execute';
-
-// TODO add tests for this
-const activateByEvent = async event => {
-  // @ts-ignore
-  await invoke$1('ActivateByEvent.activateByEvent', event);
-};
-
-const execute = async ({
-  args,
-  editorLanguageId,
-  editorUid,
-  event,
-  method,
-  noProviderFoundMessage,
-  noProviderFoundResult = undefined
-}) => {
-  const fullEvent = `${event}:${editorLanguageId}`;
-  await activateByEvent(fullEvent);
-  const result = await invoke(method, editorUid, ...args);
-  return result;
+const getTextDocument = async (editorUid, languageId) => {
+  const [lines, uri] = await Promise.all([getLines(editorUid), getUri(editorUid)]);
+  return {
+    documentId: editorUid,
+    languageId,
+    text: lines.join('\n'),
+    uri
+  };
 };
-
 const executeHoverProvider = async (editorUid, editorLanguageId, offset) => {
-  number(editorUid);
-  number(offset);
-  return execute({
-    args: [offset],
-    editorUid,
-    event: OnHover,
-    method: HoverExecute,
-    noProviderFoundMessage: 'No hover provider found'
-  });
+  const textDocument = await getTextDocument(editorUid, editorLanguageId);
+  return invoke$1('Extensions.executeHoverProvider', textDocument, offset);
 };
 
 const getHover = async (editorUid, editorLanguageId, offset) => {
   try {
     number(editorUid);
     number(offset);
-    // TODO invoke extension host worker directly
     const hover = await executeHoverProvider(editorUid, editorLanguageId, offset);
     return {
       error: undefined,
@@ -1638,7 +1830,7 @@ const getEditorHoverInfo = async (editorUid, editorLanguageId, hoverFullWidth, h
   const offset = getOffsetAtCursor();
 
   // @ts-ignore
-  const diagnostics = await invoke$1('Editor.getDiagnostics', editorUid);
+  const diagnostics = await invoke('Editor.getDiagnostics', editorUid);
   const wordPart = await getWordBefore(editorUid, rowIndex, columnIndex);
   const wordStart = columnIndex - wordPart.length;
 
@@ -1655,6 +1847,9 @@ const getEditorHoverInfo = async (editorUid, editorLanguageId, hoverFullWidth, h
     hover
   } = await getHover(editorUid, editorLanguageId, offset);
   if (!hover) {
+    if (matchingDiagnostics.length === 0) {
+      return undefined;
+    }
     return {
       documentation: '',
       lineInfos: [],
@@ -1667,6 +1862,9 @@ const getEditorHoverInfo = async (editorUid, editorLanguageId, hoverFullWidth, h
     documentation,
     lineInfos
   } = await getHoverDetails(hover, error);
+  if (!documentation && lineInfos.length === 0 && matchingDiagnostics.length === 0) {
+    return undefined;
+  }
   return {
     documentation,
     lineInfos,
@@ -1689,15 +1887,16 @@ const loadContent = async state => {
   } = await getPositionAtCursor(editorUid);
   const info = await getEditorHoverInfo(editorUid, editorLanguageId);
   if (!info) {
-    return {
-      ...state
-    };
+    return close(state);
   }
   const {
     documentation,
     lineInfos,
     matchingDiagnostics
   } = info;
+  if (!documentation && lineInfos.length === 0 && matchingDiagnostics.length === 0) {
+    return close(state);
+  }
   return {
     ...state,
     documentation,
@@ -1798,6 +1997,7 @@ const getLineInfoVirtualDom = lineInfo => {
   }
   return dom;
 };
+
 const getLineInfosVirtualDom = lineInfos => {
   const dom = lineInfos.flatMap(getLineInfoVirtualDom);
   return dom;
@@ -1805,6 +2005,8 @@ const getLineInfosVirtualDom = lineInfos => {
 
 /* eslint-disable unicorn/no-immediate-mutation */
 
+const hoverClassName = mergeClassNames(Viewlet, EditorHover);
+const problemClassName = mergeClassNames(HoverDisplayString, HoverProblem);
 const hoverProblemMessage = {
   childCount: 1,
   className: HoverProblemMessage,
@@ -1828,19 +2030,24 @@ const sash = {
 };
 const getChildCount = (lineInfos, documentation, diagnostics) => {
   const diagnosticsCount = diagnostics && diagnostics.length > 0 ? 1 : 0;
-  return lineInfos.length + documentation ? 1 : 0 + diagnosticsCount;
+  const lineInfosCount = lineInfos.length > 0 ? 1 : 0;
+  const documentationCount = documentation ? 1 : 0;
+  return lineInfosCount + documentationCount + diagnosticsCount;
 };
 const getHoverVirtualDom = (lineInfos, documentation, diagnostics) => {
+  if (lineInfos.length === 0 && !documentation && diagnostics.length === 0) {
+    return [];
+  }
   const dom = [];
   dom.push({
     childCount: getChildCount(lineInfos, documentation, diagnostics) + 1,
-    className: mergeClassNames(Viewlet, EditorHover),
+    className: hoverClassName,
     type: Div
   });
   if (diagnostics && diagnostics.length > 0) {
     dom.push({
       childCount: diagnostics.length * 2,
-      className: mergeClassNames(HoverDisplayString, HoverProblem),
+      className: problemClassName,
       type: Div
     });
     for (const diagnostic of diagnostics) {
@@ -1935,11 +2142,23 @@ const commandMap = {
   'Hover.terminate': terminate
 };
 
+const send = async port => {
+  await sendMessagePortToExtensionManagementWorker(port);
+};
+const initializeExtensionManagementWorker = async () => {
+  const rpc = await create$4({
+    commandMap: commandMap,
+    send
+  });
+  set$3(rpc);
+};
+
 const listen = async () => {
   const rpc = await create$3({
     commandMap: commandMap
   });
   set$2(rpc);
+  await initializeExtensionManagementWorker();
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/hover-worker",
-  "version": "2.15.0",
+  "version": "2.17.0",
   "description": "Web Worker for the find widget in Lvce Editor",
   "repository": {
     "type": "git",