@lvce-editor/hover-worker 1.2.0 → 1.3.0

package/dist/hoverWorkerMain.js

@@ -54,6 +54,49 @@ class VError extends Error {
   }
 }
 
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+const Object$1 = 1;
+const Number$1 = 2;
+const Array$1 = 3;
+const String = 4;
+const Boolean = 5;
+const Function = 6;
+const Null = 7;
+const Unknown = 8;
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return Number$1;
+    case 'function':
+      return Function;
+    case 'string':
+      return String;
+    case 'object':
+      if (value === null) {
+        return Null;
+      }
+      if (Array.isArray(value)) {
+        return Array$1;
+      }
+      return Object$1;
+    case 'boolean':
+      return Boolean;
+    default:
+      return Unknown;
+  }
+};
+const number = value => {
+  const type = getType(value);
+  if (type !== Number$1) {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -836,7 +879,7 @@ const send = (transport, method, ...params) => {
   const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke$3 = (ipc, method, ...params) => {
+const invoke$4 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer$3 = (ipc, method, ...params) => {
@@ -856,7 +899,7 @@ const register = commandMap => {
 const getCommand$1 = key => {
   return commands[key];
 };
-const execute = (command, ...args) => {
+const execute$1 = (command, ...args) => {
   const fn = getCommand$1(command);
   if (!fn) {
     throw new CommandNotFoundError(command);
@@ -875,7 +918,7 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$3(ipc, method, ...params);
+      return invoke$4(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
       return invokeAndTransfer$3(ipc, method, ...params);
@@ -897,7 +940,7 @@ const logError = () => {
 };
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  const actualExecute = event?.target?.execute || execute;
+  const actualExecute = event?.target?.execute || execute$1;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 const handleIpc = ipc => {
@@ -984,6 +1027,8 @@ const Text = 12;
 const EditorWorker$1 = 99;
 const ExtensionHostWorker = 44;
 
+const SetFocusContext = 'Viewlet.setFocusContext';
+
 const rpcs = Object.create(null);
 const set$5 = (id, rpc) => {
   rpcs[id] = rpc;
@@ -1017,7 +1062,7 @@ const create$2 = rpcId => {
 };
 
 const {
-  invoke: invoke$2,
+  invoke: invoke$3,
   invokeAndTransfer: invokeAndTransfer$2,
   set: set$4,
   dispose: dispose$3
@@ -1029,63 +1074,63 @@ const sendMessagePortToExtensionHostWorker$1 = async port => {
   'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, 0);
 };
 // TODO add tests for this
-const activateByEvent = async event => {
+const activateByEvent$1 = async event => {
   // @ts-ignore
-  await invoke$2('ActivateByEvent.activateByEvent', event);
+  await invoke$3('ActivateByEvent.activateByEvent', event);
 };
 const applyEdit = async (editorUid, changes) => {
   // @ts-ignore
-  await invoke$2('Editor.applyEdit2', editorUid, changes);
+  await invoke$3('Editor.applyEdit2', editorUid, changes);
 };
 const applyWorkspaceEdit = async (editorUid, changes) => {
   // @ts-ignore
-  await invoke$2('Editor.applyWorkspaceEdit', editorUid, changes);
+  await invoke$3('Editor.applyWorkspaceEdit', editorUid, changes);
 };
 const closeWidget = async (editorUid, widgetId, widgetName, focusId) => {
   // @ts-ignore
-  await invoke$2('Editor.closeWidget2', editorUid, widgetId, widgetName, focusId);
+  await invoke$3('Editor.closeWidget2', editorUid, widgetId, widgetName, focusId);
 };
 const getWordAt = async (uid, rowIndex, columnIndex) => {
   // @ts-ignore
-  const word = await invoke$2('Editor.getWordAt2', uid, rowIndex, columnIndex);
+  const word = await invoke$3('Editor.getWordAt2', uid, rowIndex, columnIndex);
   return word;
 };
 const getLines = async editorUid => {
-  const lines = await invoke$2('Editor.getLines2', editorUid);
+  const lines = await invoke$3('Editor.getLines2', editorUid);
   return lines;
 };
 const getPositionAtCursor$1 = async parentUid => {
-  const position = await invoke$2('Editor.getPositionAtCursor', parentUid);
+  const position = await invoke$3('Editor.getPositionAtCursor', parentUid);
   return position;
 };
-const getOffsetAtCursor = async editorId => {
+const getOffsetAtCursor$1 = async editorId => {
   // @ts-ignore
-  return await invoke$2('Editor.getOffsetAtCursor', editorId);
+  return await invoke$3('Editor.getOffsetAtCursor', editorId);
 };
 const getSelections = async editorUid => {
-  const selections = await invoke$2('Editor.getSelections2', editorUid);
+  const selections = await invoke$3('Editor.getSelections2', editorUid);
   return selections;
 };
 const getWordAtOffset2$1 = async editorUid => {
-  return invoke$2('Editor.getWordAtOffset2', editorUid);
+  return invoke$3('Editor.getWordAtOffset2', editorUid);
 };
 const getWordBefore = async (editorUid, rowIndex, columnIndex) => {
-  return invoke$2('Editor.getWordBefore2', editorUid, rowIndex, columnIndex);
+  return invoke$3('Editor.getWordBefore2', editorUid, rowIndex, columnIndex);
 };
 const updateDebugInfo = async info => {
-  await invoke$2('Editor.updateDebugInfo', info);
+  await invoke$3('Editor.updateDebugInfo', info);
 };
 const getUri = async editorUid => {
   // @ts-ignore
-  return invoke$2('Editor.getUri', editorUid);
+  return invoke$3('Editor.getUri', editorUid);
 };
 const getLanguageId = async editorUid => {
   // @ts-ignore
-  return invoke$2('Editor.getLanguageId', editorUid);
+  return invoke$3('Editor.getLanguageId', editorUid);
 };
 const getProblems = async () => {
   // @ts-ignore
-  return invoke$2('Editor.getProblems');
+  return invoke$3('Editor.getProblems');
 };
 const registerMockRpc$1 = commandMap => {
   const mockRpc = createMockRpc({
@@ -1097,14 +1142,14 @@ const registerMockRpc$1 = commandMap => {
 
 const EditorWorker = {
   __proto__: null,
-  activateByEvent,
+  activateByEvent: activateByEvent$1,
   applyEdit,
   applyWorkspaceEdit,
   closeWidget,
   dispose: dispose$3,
   getLanguageId,
   getLines,
-  getOffsetAtCursor,
+  getOffsetAtCursor: getOffsetAtCursor$1,
   getPositionAtCursor: getPositionAtCursor$1,
   getProblems,
   getSelections,
@@ -1112,7 +1157,7 @@ const EditorWorker = {
   getWordAt,
   getWordAtOffset2: getWordAtOffset2$1,
   getWordBefore,
-  invoke: invoke$2,
+  invoke: invoke$3,
   invokeAndTransfer: invokeAndTransfer$2,
   registerMockRpc: registerMockRpc$1,
   sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
@@ -1121,22 +1166,22 @@ const EditorWorker = {
 };
 
 const {
-  invoke: invoke$1,
+  invoke: invoke$2,
   invokeAndTransfer: invokeAndTransfer$1,
   set: set$3,
   dispose: dispose$2
 } = create$2(ExtensionHostWorker);
 const executeReferenceProvider = async (id, offset) => {
   // @ts-ignore
-  return invoke$1('ExtensionHostReference.executeReferenceProvider', id, offset);
+  return invoke$2('ExtensionHostReference.executeReferenceProvider', id, offset);
 };
 const executeFileReferenceProvider = async id => {
   // @ts-ignore
-  return invoke$1('ExtensionHostReference.executeFileReferenceProvider', id);
+  return invoke$2('ExtensionHostReference.executeFileReferenceProvider', id);
 };
 const getRuntimeStatus = async extensionId => {
   // @ts-ignore
-  return invoke$1('ExtensionHost.getRuntimeStatus', extensionId);
+  return invoke$2('ExtensionHost.getRuntimeStatus', extensionId);
 };
 const registerMockRpc = commandMap => {
   const mockRpc = createMockRpc({
@@ -1152,14 +1197,14 @@ const ExtensionHost = {
   executeFileReferenceProvider,
   executeReferenceProvider,
   getRuntimeStatus,
-  invoke: invoke$1,
+  invoke: invoke$2,
   invokeAndTransfer: invokeAndTransfer$1,
   registerMockRpc,
   set: set$3
 };
 
 const {
-  invoke,
+  invoke: invoke$1,
   set: set$2,
   invokeAndTransfer,
   getWordAtOffset2
@@ -1175,7 +1220,7 @@ const close = async state => {
     editorUid
   } = state;
   // @ts-ignore
-  await invoke('Editor.closeWidget2', editorUid, Hover, 'Hovers', FocusEditorHovers);
+  await invoke$1('Editor.closeWidget2', editorUid, Hover, 'Hovers', FocusEditorHovers);
   return state;
 };
 
@@ -1288,7 +1333,10 @@ const create = (uid, x, y, width, height, editorUid, editorLanguageId) => {
     hoverBorderRight: 1,
     hoverPaddingLeft: 8,
     hoverPaddingRight: 8,
-    hovverFullWidth: 400
+    hoverFullWidth: 400,
+    documentation: '',
+    lineInfos: [],
+    matchingDiagnostics: []
   };
   set$1(uid, state, state);
 };
@@ -1451,6 +1499,7 @@ const createExtensionHostRpc = async () => {
 };
 
 const {
+  invoke,
   set
 } = ExtensionHost;
 
@@ -1459,27 +1508,180 @@ const initialize = async () => {
   set(rpc);
 };
 
+//  @deprecated this doesn't work for variable width characters (unicode/emoji).
+// Use position computation in renderer process instead
+
+/*
+ * @param {object} editor
+ * @param {number} rowIndex
+ * @param {number} columnIndex
+ * @returns
+ */
+const x = (editor, rowIndex, columnIndex) => {
+  const {
+    columnWidth,
+    x
+  } = editor;
+  const offsetX = columnIndex * columnWidth + x;
+  return offsetX;
+};
+const y = (editor, rowIndex) => {
+  const {
+    rowHeight,
+    y
+  } = editor;
+  const offsetY = (rowIndex + 1) * rowHeight + y;
+  return offsetY;
+};
+
+const getOffsetAtCursor = editorUid => {
+  // TODO ask editor worker
+  return 0;
+};
+
 const getPositionAtCursor = async editorUid => {
-  const position = await invoke('Editor.getPositionAtCursor', editorUid);
+  const position = await invoke$1('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 ({
+  editorLanguageId,
+  editorUid,
+  args,
+  event,
+  method,
+  noProviderFoundMessage,
+  noProviderFoundResult = undefined
+}) => {
+  const fullEvent = `${event}:${editorLanguageId}`;
+  await activateByEvent(fullEvent);
+  const result = await invoke(method, editorUid, ...args);
+  return result;
+};
+
+const executeHoverProvider = async (editorUid, editorLanguageId, offset) => {
+  number(editorUid);
+  number(offset);
+  return execute({
+    event: OnHover,
+    editorUid,
+    method: HoverExecute,
+    args: [offset],
+    noProviderFoundMessage: 'No hover provider found'
+  });
+};
+
+const getHover = async (editorUid, editorLanguageId, offset) => {
+  number(editorUid);
+  number(offset);
+  // TODO invoke extension host worker directly
+  const hover = await executeHoverProvider(editorUid, editorLanguageId, offset);
+  return hover;
+};
+
+const measureTextBlockHeight = async (text, fontFamily, fontSize, lineHeight, width) => {
+  // TODO ask editor worker or renderer process
+  return 100;
+};
+
+const tokenizeCodeBlock = async (codeBlock, languageId, tokenizerPath) => {
+  // TODO maybe use syntax highlighting worker for this or another worker
+  return [];
+};
+
+const getMatchingDiagnostics = (diagnostics, rowIndex, columnIndex) => {
+  const matching = [];
+  for (const diagnostic of diagnostics) {
+    if (diagnostic.rowIndex === rowIndex) {
+      matching.push(diagnostic);
+    }
+  }
+  return matching;
+};
+const getHoverPositionXy = (editor, rowIndex, wordStart, documentationHeight) => {
+  const x$1 = x(editor, rowIndex, wordStart);
+  const y$1 = editor.height - y(editor, rowIndex) + editor.y + 40;
+  return {
+    x: x$1,
+    y: y$1
+  };
+};
+const getEditorHoverInfo = async (editorUid, editorLanguageId, hoverFullWidth, hoverPaddingLeft, hoverPaddingRight, hoverBorderLeft, hoverBorderRight, hoverDocumentationFontFamily, hoverDocumentationFontSize, hoverDocumentationLineHeight, fallbackDisplayStringLanguageId) => {
+  number(editorUid);
+  const {
+    rowIndex,
+    columnIndex
+  } = await getPositionAtCursor(editorUid);
+  const offset = getOffsetAtCursor();
+  const hover = await getHover(editorUid, editorLanguageId, offset);
+  if (!hover) {
+    return undefined;
+  }
+  const {
+    documentation} = hover;
+  const lineInfos = await tokenizeCodeBlock();
+  const wordPart = await getWordBefore(editorUid, rowIndex, columnIndex);
+  const wordStart = columnIndex - wordPart.length;
+  await measureTextBlockHeight();
+  // TODO
+  const editor = {};
+  const {
+    x,
+    y
+  } = getHoverPositionXy(editor, rowIndex, wordStart);
+  // @ts-ignore
+  const diagnostics = editor.diagnostics || [];
+  const matchingDiagnostics = getMatchingDiagnostics(diagnostics, rowIndex);
+  return {
+    lineInfos,
+    documentation,
+    x,
+    y,
+    matchingDiagnostics
+  };
+};
+
 const getWordAtOffset = getWordAtOffset2;
 
 const loadContent = async state => {
   const {
-    editorUid
-  } = state;
+    editorLanguageId,
+    editorUid} = state;
   const wordAtOffset = await getWordAtOffset(editorUid);
   const {
     x,
     y
   } = await getPositionAtCursor(editorUid);
+  const info = await getEditorHoverInfo(editorUid, editorLanguageId);
+  if (!info) {
+    return {
+      ...state
+    };
+  }
+  const {
+    documentation,
+    lineInfos,
+    matchingDiagnostics
+  } = info;
   return {
     ...state,
     leadingWord: wordAtOffset,
     x,
-    y
+    y,
+    documentation,
+    lineInfos,
+    matchingDiagnostics,
+    width: 300
   };
 };
 
@@ -1527,7 +1729,7 @@ const renderEventListeners = state => {
 };
 
 const renderFocusContext = (oldState, newState) => {
-  return [/* method */'Viewlet.setFocusContext', FocusEditorRename];
+  return [SetFocusContext, FocusEditorRename];
 };
 
 const HoverDisplayString = 'HoverDisplayString';
@@ -1627,9 +1829,12 @@ const getHoverVirtualDom = (lineInfos, documentation, diagnostics) => {
 
 const renderItems = (oldState, newState) => {
   const {
-    uid
+    uid,
+    matchingDiagnostics,
+    documentation,
+    lineInfos
   } = newState;
-  const dom = getHoverVirtualDom([], {}, {});
+  const dom = getHoverVirtualDom(lineInfos, documentation, matchingDiagnostics);
   return [/* method */'Viewlet.setDom2', uid, dom];
 };
 

package/package.json

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