@lvce-editor/static-server 0.67.2 → 0.67.4

package/static/{206fa4b → f1498c6}/packages/editor-worker/dist/editorWorkerMain.js

@@ -899,7 +899,7 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const send = (transport, method, ...params) => {
+const send$1 = (transport, method, ...params) => {
   const message = create$4$2(method, params);
   transport.send(message);
 };
@@ -939,7 +939,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
+      send$1(ipc, method, ...params);
     },
     invoke(method, ...params) {
       return invoke$c(ipc, method, ...params);
@@ -1136,6 +1136,7 @@ const EditorWorker = 99;
 const ExtensionHostWorker = 44;
 const MarkdownWorker = 300;
 const RendererWorker = 1;
+const TextMeasurementWorker = 7011;
 
 const FocusEditorText$1 = 12;
 
@@ -1216,6 +1217,11 @@ const {
   invoke: invoke$a,
   invokeAndTransfer: invokeAndTransfer$1,
   set: set$9} = create$9(RendererWorker);
+const sendMessagePortToTextMeasurementWorker = async port => {
+  const command = 'TextMeasurement.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
+};
 
 const {
   invoke: invoke$9,
@@ -2435,7 +2441,12 @@ const getTabCount = string => {
   return count;
 };
 
-const measureTextWidthFast = (text, charWidth) => {
+const RE_ASCII = /^[\p{ASCII}]*$/u;
+const isAscii = line => {
+  return RE_ASCII.test(line);
+};
+
+const measureTextWidthFast = async (text, charWidth) => {
   return text.length * charWidth;
 };
 
@@ -2474,7 +2485,7 @@ const getContext = () => {
 
 // TODO for text editor, could dispose measuring canvas after editor has been initialized to free up offscreencanvas space
 
-const measureTextWidthSlow = (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
+const measureTextWidthSlow = async (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
   string(text);
   number(fontWeight);
   number(fontSize);
@@ -2496,14 +2507,18 @@ const measureTextWidthSlow = (text, fontWeight, fontSize, fontFamily, letterSpac
   return width;
 };
 
-const measureTextWidth = (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
-  if (isMonoSpaceFont) {
-    return measureTextWidthFast(text, charWidth);
+const measureTextWidth = async (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
+  // TODO maybe have a property for the whole text document
+  // whether the document is ascii or not
+  // so that it doesn't need to be checked on every cursor change
+  // or scroll position change
+  if (isMonoSpaceFont && isAscii(text)) {
+    return await measureTextWidthFast(text, charWidth);
   }
-  return measureTextWidthSlow(text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth);
+  return await measureTextWidthSlow(text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth);
 };
 
-const getX = (line, column, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, difference = 0) => {
+const getX = async (line, column, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, difference = 0) => {
   if (!line) {
     return 0;
   }
@@ -2525,7 +2540,8 @@ const getX = (line, column, fontWeight, fontSize, fontFamily, isMonospaceFont, l
   const normalizedLine = normalizeText(line, normalize, tabSize);
   const tabCount = getTabCount(line.slice(0, column));
   const partialText = normalizedLine.slice(0, column + tabCount);
-  return measureTextWidth(partialText, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, averageCharWidth) - halfCursorWidth + difference;
+  const textWidth = await measureTextWidth(partialText, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, averageCharWidth);
+  return textWidth - halfCursorWidth + difference;
 };
 
 const getY = (row, minLineY, rowHeight) => {
@@ -2642,7 +2658,7 @@ const getSelectionArray = visibleSelections => {
   }
   return selectionsArray;
 };
-const getVisible = editor => {
+const getVisible = async editor => {
   const visibleCursors = [];
   const visibleSelections = [];
   // // TODO binary search
@@ -2675,7 +2691,7 @@ const getVisible = editor => {
     const relativeEndLineRow = selectionEndRow - minLineY;
     const endLineDifference = differences[relativeEndLineRow];
     const endLine = lines[selectionEndRow];
-    const endLineEndX = getX(endLine, selectionEndColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, endLineDifference);
+    const endLineEndX = await getX(endLine, selectionEndColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, endLineDifference);
     const endLineY = getY(selectionEndRow, minLineY, rowHeight);
     if (isEmpty(selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) && endLineEndX > 0) {
       visibleCursors.push(endLineEndX, endLineY);
@@ -2685,7 +2701,7 @@ const getVisible = editor => {
     const startLineYRelative = selectionStartRow - minLineY;
     const startLineDifference = differences[startLineYRelative];
     if (selectionStartRow === selectionEndRow) {
-      const startX = getX(endLine, selectionStartColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
+      const startX = await getX(endLine, selectionStartColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
       if (reversed) {
         visibleCursors.push(startX, endLineY);
       } else if (endLineEndX >= 0) {
@@ -2696,8 +2712,8 @@ const getVisible = editor => {
     } else {
       if (selectionStartRow >= minLineY) {
         const startLine = lines[selectionStartRow];
-        const startLineStartX = getX(startLine, selectionStartColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
-        const startLineEndX = getX(startLine, startLine.length, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
+        const startLineStartX = await getX(startLine, selectionStartColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
+        const startLineEndX = await getX(startLine, startLine.length, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
         const startLineStartY = getY(selectionStartRow, minLineY, rowHeight);
         const selectionWidth = startLineEndX - startLineStartX;
         if (reversed) {
@@ -2712,7 +2728,7 @@ const getVisible = editor => {
         const currentLineY = getY(i, minLineY, rowHeight);
         const relativeLine = i - minLineY;
         const difference = differences[relativeLine];
-        const selectionWidth = getX(currentLine, currentLine.length, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, difference);
+        const selectionWidth = await getX(currentLine, currentLine.length, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, difference);
         visibleSelections.push(0, currentLineY, selectionWidth, rowHeight);
       }
       if (selectionEndRow <= maxLineY) {
@@ -3131,8 +3147,8 @@ const getLanguages = async () => {
   return languages;
 };
 
-const measureCharacterWidth = (fontWeight, fontSize, fontFamily, letterSpacing) => {
-  return measureTextWidth('a', fontWeight, fontSize, fontFamily, letterSpacing, false, 0);
+const measureCharacterWidth = async (fontWeight, fontSize, fontFamily, letterSpacing) => {
+  return await measureTextWidth('a', fontWeight, fontSize, fontFamily, letterSpacing, false, 0);
 };
 
 const get$1 = async key => {
@@ -3171,7 +3187,7 @@ const getDiagnosticType = diagnostic => {
   return diagnostic.type;
 };
 
-const getVisibleDiagnostics = (editor, diagnostics) => {
+const getVisibleDiagnostics = async (editor, diagnostics) => {
   const visibleDiagnostics = [];
   const {
     width,
@@ -3196,7 +3212,7 @@ const getVisibleDiagnostics = (editor, diagnostics) => {
     const diagnosticWidth = columnDelta * charWidth;
     const endLineDifference = 0;
     const halfCursorWidth = 0;
-    const x = getX(lines[rowIndex], columnIndex, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, charWidth, endLineDifference);
+    const x = await getX(lines[rowIndex], columnIndex, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, charWidth, endLineDifference);
     const y = getY(rowIndex, minLineY, rowHeight) - rowHeight;
     visibleDiagnostics.push({
       x,
@@ -3228,7 +3244,7 @@ const updateDiagnostics = async newState => {
     if (!latest) {
       return newState;
     }
-    const decorations = getVisibleDiagnostics(latest.newState, diagnostics);
+    const decorations = await getVisibleDiagnostics(latest.newState, diagnostics);
     const newEditor = {
       ...latest.newState,
       diagnostics,
@@ -3282,7 +3298,7 @@ const createEditor = async ({
   number(id);
   string(content);
   // TODO support overwriting language id by setting it explicitly or via settings
-  const charWidth = measureCharacterWidth(fontWeight, fontSize, fontFamily, letterSpacing);
+  const charWidth = await measureCharacterWidth(fontWeight, fontSize, fontFamily, letterSpacing);
   const languages = await getLanguages();
   const computedlanguageId = getLanguageId$1(uri, languages);
   const editor = {
@@ -3582,9 +3598,9 @@ const editorReplaceSelections = (editor, replacement, origin) => {
   return replaceRange(editor, selections, replacement, origin);
 };
 
-const getAccurateColumnIndexAscii = (line, guess, averageCharWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth) => {
+const getAccurateColumnIndexAscii = async (line, guess, averageCharWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth) => {
   for (let i = guess; i < line.length; i++) {
-    const width = measureTextWidth(line.slice(0, i), fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+    const width = await measureTextWidth(line.slice(0, i), fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
     if (eventX - width < averageCharWidth / 2) {
       return i;
     }
@@ -3631,14 +3647,13 @@ const create$8 = () => {
   };
 };
 
-// @ts-ignore
-const getAccurateColumnIndexUnicode = (line, guess, averageCharWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing) => {
+const getAccurateColumnIndexUnicode = async (line, guess, averageCharWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing) => {
   const segmenter = create$8();
   const segments = segmenter.getSegments(line);
   const isMonospaceFont = false;
   const charWidth = 0;
   for (const segment of segments) {
-    const width = measureTextWidth(line.slice(0, segment.index), fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+    const width = await measureTextWidth(line.slice(0, segment.index), fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
     if (eventX - width < averageCharWidth) {
       return segment.index;
     }
@@ -3646,18 +3661,10 @@ const getAccurateColumnIndexUnicode = (line, guess, averageCharWidth, eventX, fo
   return line.length;
 };
 
-const RE_ASCII = /^[\p{ASCII}]*$/u;
-const isAscii = line => {
-  return RE_ASCII.test(line);
-};
-
-// @ts-ignore
 const guessOffset = (eventX, averageCharWidth) => {
   const guess = Math.round(eventX / averageCharWidth);
   return guess;
 };
-
-// @ts-ignore
 const normalizeGuess = (line, guess, tabSize) => {
   let normalizedGuess = guess;
   for (let i = 0; i < guess; i++) {
@@ -3667,9 +3674,7 @@ const normalizeGuess = (line, guess, tabSize) => {
   }
   return normalizedGuess;
 };
-
-// @ts-ignore
-const getAccurateColumnIndex = (line, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth, tabSize, eventX) => {
+const getAccurateColumnIndex = async (line, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth, tabSize, eventX) => {
   string(line);
   number(fontWeight);
   number(fontSize);
@@ -3685,18 +3690,18 @@ const getAccurateColumnIndex = (line, fontWeight, fontSize, fontFamily, letterSp
   const normalizedGuess = normalizeGuess(line, guess, tabSize);
   const text = line.slice(0, normalizedGuess);
   const normalizedText = normalizeText(text, normalize, tabSize);
-  const actual = measureTextWidth(normalizedText, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+  const actual = await measureTextWidth(normalizedText, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
   const isAscii$1 = isAscii(line);
   if (isAscii$1) {
     if (Math.abs(eventX - actual) < charWidth / 2) {
       return normalizedGuess;
     }
-    return getAccurateColumnIndexAscii(line, normalizedGuess, charWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+    return await getAccurateColumnIndexAscii(line, normalizedGuess, charWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
   }
-  return getAccurateColumnIndexUnicode(line, normalizedGuess, charWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing);
+  return await getAccurateColumnIndexUnicode(line, normalizedGuess, charWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing);
 };
 
-const at = (editor, eventX, eventY) => {
+const at = async (editor, eventX, eventY) => {
   object(editor);
   number(eventX);
   number(eventY);
@@ -3722,7 +3727,7 @@ const at = (editor, eventX, eventY) => {
   }
   const clampedRowIndex = clamp(rowIndex, 0, lines.length - 1);
   const line = lines[clampedRowIndex];
-  const columnIndex = getAccurateColumnIndex(line, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth, tabSize, eventX);
+  const columnIndex = await getAccurateColumnIndex(line, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth, tabSize, eventX);
   return {
     rowIndex: clampedRowIndex,
     columnIndex
@@ -5269,8 +5274,8 @@ const selectWord = (editor, rowIndex, columnIndex) => {
   return scheduleSelections(editor, newSelections);
 };
 
-const handleDoubleClick = (editor, modifier, x, y) => {
-  const position = at(editor, x, y);
+const handleDoubleClick = async (editor, modifier, x, y) => {
+  const position = await at(editor, x, y);
   return selectWord(editor, position.rowIndex, position.columnIndex);
 };
 
@@ -5295,7 +5300,7 @@ const handleSingleClick = async (editor, modifier, x, y) => {
   number(modifier);
   number(x);
   number(y);
-  const position = at(editor, x, y);
+  const position = await at(editor, x, y);
   return handleClickAtPosition(editor, modifier, position.rowIndex, position.columnIndex);
 };
 
@@ -5379,7 +5384,7 @@ const onHoverIdle = async () => {
     y,
     editor
   } = get();
-  at(editor, x, y);
+  await at(editor, x, y);
   await showHover$1();
 };
 const hoverDelay = 300;
@@ -5416,7 +5421,7 @@ const handleMouseMoveWithAltKey = async (editor, x, y) => {
   object(editor);
   number(x);
   number(y);
-  const position = at(editor, x, y);
+  const position = await at(editor, x, y);
   const documentOffset = offsetAt(editor, position.rowIndex, position.columnIndex);
   try {
     const definition = await getDefinition(editor, documentOffset);
@@ -5971,8 +5976,8 @@ const moveRectangleSelection = (editor, position) => {
 };
 
 // @ts-ignore
-const moveRectangleSelectionPx = (editor, x, y) => {
-  at(editor, x, y);
+const moveRectangleSelectionPx = async (editor, x, y) => {
+  await at(editor, x, y);
 };
 
 const LessThan = -1;
@@ -6107,11 +6112,11 @@ const continueScrollingAndMovingSelection = async () => {
 };
 
 // @ts-ignore
-const moveSelectionPx = (editor, x, y) => {
+const moveSelectionPx = async (editor, x, y) => {
   object(editor);
   number(x);
   number(y);
-  const position = at(editor, x, y);
+  const position = await at(editor, x, y);
   if (!hasListener() && (position.rowIndex < editor.minLineY || position.rowIndex > editor.maxLineY)) {
     requestAnimationFrame(continueScrollingAndMovingSelection);
     setEditor(editor);
@@ -6191,7 +6196,7 @@ const create$4 = () => {
 };
 
 const {
-  setFactory,
+  setFactory: setFactory$1,
   invoke: invoke$4
 } = createLazyRpc(CompletionWorker);
 
@@ -9849,7 +9854,7 @@ const launchCompletionWorker = async () => {
 };
 
 const intialize = async (syntaxHighlightingEnabled, syncIncremental) => {
-  setFactory(launchCompletionWorker);
+  setFactory$1(launchCompletionWorker);
   await Promise.all([initializeSyntaxHighlighting(syntaxHighlightingEnabled, syncIncremental), initializeExtensionHost()]);
 };
 
@@ -10074,11 +10079,11 @@ const renderSelections = {
   isEqual(oldState, newState) {
     return oldState.selections === newState.selections && oldState.focused === newState.focused && oldState.minLineY === newState.minLineY && oldState.deltaX === newState.deltaX;
   },
-  apply(oldState, newState) {
+  apply: async (oldState, newState) => {
     const {
       cursorInfos,
       selectionInfos
-    } = getVisible(newState);
+    } = await getVisible(newState);
     const cursorsDom = getCursorsVirtualDom(cursorInfos);
     const selectionsDom = getSelectionsVirtualDom(selectionInfos);
     return [/* method */'setSelections', cursorsDom, selectionsDom];
@@ -10219,7 +10224,7 @@ const renderWidgets = {
   multiple: true
 };
 const render$6 = [renderLines, renderSelections, renderScrollBarX, renderScrollBarY, renderFocus$1, renderDecorations, renderGutterInfo, renderWidgets, renderFocusContext, renderAdditionalFocusContext];
-const renderEditor = id => {
+const renderEditor = async id => {
   const instance = get$5(id);
   if (!instance) {
     return [];
@@ -10232,7 +10237,7 @@ const renderEditor = id => {
   set$6(id, newState, newState);
   for (const item of render$6) {
     if (!item.isEqual(oldState, newState)) {
-      const result = item.apply(oldState, newState);
+      const result = await item.apply(oldState, newState);
       // @ts-ignore
       if (item.multiple) {
         commands.push(...result);
@@ -10361,7 +10366,7 @@ const wrapCommand = fn => async (editorUid, ...args) => {
   // TODO combine neweditor with latest editor?
 
   set$6(editorUid, state, newEditor);
-  const commands = renderEditor(editorUid);
+  const commands = await renderEditor(editorUid);
   return {
     ...newEditor,
     commands
@@ -10617,7 +10622,28 @@ const commandMap = {
 };
 wrapCommands(commandMap);
 
+const send = port => {
+  // @ts-ignore
+  return sendMessagePortToTextMeasurementWorker(port);
+};
+const createTextMeasurementWorkerRpc = async () => {
+  try {
+    const rpc = await TransferMessagePortRpcParent.create({
+      commandMap: {},
+      send
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create text measurement worker rpc`);
+  }
+};
+
+const {
+  setFactory
+} = createLazyRpc(TextMeasurementWorker);
+
 const listen = async () => {
+  setFactory(createTextMeasurementWorkerRpc);
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });

package/static/{206fa4b → f1498c6}/packages/explorer-worker/dist/explorerViewWorkerMain.js

@@ -2610,7 +2610,8 @@ const create = (id, uri, x, y, width, height, args, parentUid, platform = 0) =>
     maxIndent: 0,
     errorMessageLeft: 0,
     errorMessageTop: 0,
-    visibleExplorerItems: []
+    visibleExplorerItems: [],
+    errorMessageWidth: 0
   };
   set(state.uid, state, state);
   return state;
@@ -2625,7 +2626,7 @@ const isEqual$6 = (oldState, newState) => {
   // TODO compute css more optimized
   // maybe only when items change, and even then not
   // always, but only when it affects the css
-  return oldState.errorMessageLeft === newState.errorMessageLeft && oldState.errorMessageTop === newState.errorMessageTop && oldState.maxIndent === newState.maxIndent && oldState.scrollBarActive === newState.scrollBarActive && oldState.scrollBarHeight === newState.scrollBarHeight && oldState.visibleExplorerItems === newState.visibleExplorerItems;
+  return oldState.errorMessageLeft === newState.errorMessageLeft && oldState.errorMessageTop === newState.errorMessageTop && oldState.maxIndent === newState.maxIndent && oldState.scrollBarActive === newState.scrollBarActive && oldState.scrollBarHeight === newState.scrollBarHeight && oldState.visibleExplorerItems === newState.visibleExplorerItems && oldState.editingErrorMessage === newState.editingErrorMessage;
 };
 
 const isEqual$5 = (oldState, newState) => {
@@ -4962,6 +4963,10 @@ const confirmDelete = async paths => {
   return result === true;
 };
 
+const showErrorAlert = async errorMessage => {
+  await confirm(errorMessage);
+};
+
 const removeDirent = async state => {
   const {
     items,
@@ -4988,7 +4993,7 @@ const removeDirent = async state => {
   // TODO use bulk edit and explorer refresh
   const errorMessage = await applyFileOperations(fileOperations);
   if (errorMessage) {
-    await confirm(errorMessage);
+    await showErrorAlert(errorMessage);
     return state;
   }
   const newState = await refresh(state);
@@ -5070,16 +5075,28 @@ const getIndentRule = indent => {
   padding-left: ${indent}px;
 }`;
 };
-const getCss = (scrollBarHeight, uniqueIndents, errorMessageLeft, errorMessageTop) => {
+const getCss = (scrollBarHeight, uniqueIndents, errorMessageLeft, errorMessageTop, errorMessageWidth) => {
   const rules = [`.Explorer {
   --ScrollBarThumbHeight: ${scrollBarHeight}px;
   --ErrorMessageTop: ${errorMessageTop}px;
   --ErrorMessageLeft: ${errorMessageLeft}px;
+  --ErrorMessageWidth: ${errorMessageWidth}px;
 }`, ...uniqueIndents.map(getIndentRule)];
   const css = rules.join('\n');
   return css;
 };
 
+const getErrorMessagePosition = (itemHeight, focusedIndex, minLineY, depth, indent, fileIconWidth, padding, width) => {
+  const top = itemHeight * (focusedIndex - minLineY + 1);
+  const left = depth * indent + fileIconWidth + padding;
+  const errorMessageWidth = width - left;
+  return {
+    top,
+    left,
+    errorMessageWidth
+  };
+};
+
 const getUnique = items => {
   const seens = [];
   for (const item of items) {
@@ -5092,15 +5109,29 @@ const getUnique = items => {
 
 const renderCss = (oldState, newState) => {
   const {
+    width,
+    items,
     scrollBarHeight,
     uid,
     visibleExplorerItems,
-    errorMessageLeft,
-    errorMessageTop
+    itemHeight,
+    focusedIndex,
+    minLineY
   } = newState;
   const indents = visibleExplorerItems.map(item => item.indent);
   const uniqueIndents = getUnique(indents);
-  const css = getCss(scrollBarHeight, uniqueIndents, errorMessageLeft, errorMessageTop);
+  const indent = 8;
+  const padding = 10;
+  const fileIconWidth = 16;
+  const defaultPaddingLeft = 0;
+  const chevronSpace = 22;
+  const depth = items[focusedIndex]?.depth || 0;
+  const {
+    top,
+    left,
+    errorMessageWidth
+  } = getErrorMessagePosition(itemHeight, focusedIndex, minLineY, depth, indent, fileIconWidth, padding + defaultPaddingLeft + chevronSpace, width);
+  const css = getCss(scrollBarHeight, uniqueIndents, left, top, errorMessageWidth);
   return [SetCss, uid, css];
 };
 
@@ -5180,15 +5211,6 @@ const renderFocusContext = (oldState, newState) => {
   return [];
 };
 
-const getErrorMessagePosition = (itemHeight, focusedIndex, minLineY, depth, indent, fileIconWidth, padding) => {
-  const top = itemHeight * (focusedIndex - minLineY + 1);
-  const left = depth * indent + fileIconWidth + padding;
-  return {
-    top,
-    left
-  };
-};
-
 const None = 'none';
 const ToolBar = 'toolbar';
 const Tree = 'tree';
@@ -5200,16 +5222,14 @@ const Input = 6;
 const Img = 17;
 const P = 50;
 
-const getErrorMessageDom = (errorMessage, errorMessageLeft, errorMessageTop) => {
+const getErrorMessageDom = errorMessage => {
   if (!errorMessage) {
     return [];
   }
-  const translateString = position(errorMessageLeft, errorMessageTop);
   return [{
     type: Div,
     className: mergeClassNames(ExplorerErrorMessage),
-    childCount: 1,
-    translate: translateString
+    childCount: 1
   }, text(errorMessage)];
 };
 
@@ -5440,14 +5460,14 @@ const getChildCount = (scrollBarDomLength, errorDomLength) => {
   }
   return childCount;
 };
-const getExplorerVirtualDom = (visibleItems, focusedIndex, root, isWide, focused, dropTargets, height, contentHeight, scrollTop, errorMessage, errorMessageTop, errorMessageLeft) => {
+const getExplorerVirtualDom = (visibleItems, focusedIndex, root, isWide, focused, dropTargets, height, contentHeight, scrollTop, errorMessage) => {
   if (!root) {
     return getExplorerWelcomeVirtualDom(isWide);
   }
   const scrollBarHeight = getScrollBarSize(height, contentHeight, 20);
   const scrollBarTop = getScrollBarTop(height, contentHeight, scrollTop);
   const scrollBarDom = getScrollBarVirtualDom(scrollBarHeight, scrollBarTop);
-  const errorDom = getErrorMessageDom(errorMessage, errorMessageLeft, errorMessageTop);
+  const errorDom = getErrorMessageDom(errorMessage);
   const childCount = getChildCount(scrollBarDom.length, errorDom.length);
   const parentNode = {
     type: Div,
@@ -5469,24 +5489,13 @@ const renderItems = (oldState, newState) => {
     height,
     itemHeight,
     items,
-    minLineY,
     root,
     width
   } = newState;
   const visibleDirents = newState.visibleExplorerItems;
   const isWide = width > 450;
   const contentHeight = items.length * itemHeight;
-  const depth = items[focusedIndex]?.depth || 0;
-  const indent = 8;
-  const padding = 10;
-  const fileIconWidth = 16;
-  const defaultPaddingLeft = 0;
-  const chevronSpace = 22;
-  const {
-    top,
-    left
-  } = getErrorMessagePosition(itemHeight, focusedIndex, minLineY, depth, indent, fileIconWidth, padding + defaultPaddingLeft + chevronSpace);
-  const dom = getExplorerVirtualDom(visibleDirents, focusedIndex, root, isWide, focused, dropTargets, height, contentHeight, deltaY, editingErrorMessage, top, left);
+  const dom = getExplorerVirtualDom(visibleDirents, focusedIndex, root, isWide, focused, dropTargets, height, contentHeight, deltaY, editingErrorMessage);
   return [SetDom2, dom];
 };
 

package/static/{206fa4b → f1498c6}/packages/extension-host-worker/dist/extensionHostWorkerMain.js

@@ -2740,7 +2740,7 @@ const {
 });
 
 const getExtensionHostSubWorkerUrl = () => {
-  return '/206fa4b/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
+  return '/f1498c6/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
 };
 const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
 
@@ -3018,9 +3018,9 @@ const getJson = async url => {
 
 const getAssetDir = () => {
   // @ts-ignore
-  if (typeof '/206fa4b' !== 'undefined') {
+  if (typeof '/f1498c6' !== 'undefined') {
     // @ts-ignore
-    return '/206fa4b';
+    return '/f1498c6';
   }
   if (platform === Electron) {
     return '../../../../..';