@lvce-editor/editor-worker 19.72.5 → 19.72.6

package/dist/editorWorkerMain.js

@@ -2463,77 +2463,132 @@ const getHorizontalVisibleRange = (line, deltaX, width, averageCharWidth, tabSiz
     start
   };
 };
-const getHorizontalVisibleRangeMeasured = async (line, deltaX, width, averageCharWidth, tabSize, threshold, measureWidth) => {
-  const fallback = () => {
-    const range = getHorizontalVisibleRange(line, deltaX, width, averageCharWidth, tabSize, threshold);
+const getHorizontalVisibleRangesMeasured = async (requests, measureWidths) => {
+  const fallback = request => {
+    const range = getHorizontalVisibleRange(request.line, request.deltaX, request.width, request.averageCharWidth, request.tabSize, request.threshold);
     return {
       ...range,
-      difference: getHorizontalVisibleDifference(line, range.start, deltaX, averageCharWidth, tabSize)
+      difference: getHorizontalVisibleDifference(request.line, range.start, request.deltaX, request.averageCharWidth, request.tabSize)
     };
   };
-  if (line.length <= threshold) {
-    return fallback();
+  const results = requests.map(request => fallback(request));
+  const boundariesByLine = [];
+  const measurementsByLine = [];
+  const cursors = [];
+  for (let lineIndex = 0; lineIndex < requests.length; lineIndex++) {
+    const request = requests[lineIndex];
+    if (request.line.length <= request.threshold) {
+      continue;
+    }
+    const segments = getSegments(request.line);
+    const boundaries = [0, ...segments.map(({
+      index,
+      segment
+    }) => index + segment.length)];
+    boundariesByLine[lineIndex] = boundaries;
+    measurementsByLine[lineIndex] = new Map([[0, 0]]);
+    const scrollOffset = Math.max(0, Number.isFinite(request.deltaX) ? request.deltaX : 0);
+    const viewportWidth = Number.isFinite(request.width) ? Math.max(0, request.width) : Infinity;
+    cursors.push({
+      high: boundaries.length,
+      isStart: true,
+      lineIndex,
+      low: 0,
+      target: scrollOffset
+    });
+    cursors.push({
+      high: boundaries.length,
+      isStart: false,
+      lineIndex,
+      low: 0,
+      target: scrollOffset + viewportWidth
+    });
   }
-  const scrollOffset = Math.max(0, Number.isFinite(deltaX) ? deltaX : 0);
-  const viewportWidth = Number.isFinite(width) ? Math.max(0, width) : Infinity;
-  const segments = getSegments(line);
-  const boundaries = [0, ...segments.map(({
-    index,
-    segment
-  }) => index + segment.length)];
-  const measurements = new Map([[0, 0]]);
-  const measureBoundary = async boundaryIndex => {
-    const cached = measurements.get(boundaryIndex);
-    if (cached !== undefined) {
-      return cached;
-    }
-    const prefix = line.slice(0, boundaries[boundaryIndex]).replaceAll('\t', () => ' '.repeat(tabSize));
-    const measured = await measureWidth(prefix);
-    measurements.set(boundaryIndex, measured);
-    return measured;
-  };
-  const findGreatestBoundaryAtMost = async target => {
-    let low = 0;
-    let high = boundaries.length;
-    while (low < high) {
-      const middle = Math.floor((low + high) / 2);
-      if ((await measureBoundary(middle)) <= target) {
-        low = middle + 1;
-      } else {
-        high = middle;
+  try {
+    const addPendingMeasurement = (cursor, pending) => {
+      if (cursor.low >= cursor.high) {
+        return;
       }
-    }
-    return Math.max(0, low - 1);
-  };
-  const findFirstBoundaryAtLeast = async target => {
-    let low = 0;
-    let high = boundaries.length;
-    while (low < high) {
-      const middle = Math.floor((low + high) / 2);
-      if ((await measureBoundary(middle)) < target) {
-        low = middle + 1;
+      const boundaryIndex = Math.floor((cursor.low + cursor.high) / 2);
+      if (measurementsByLine[cursor.lineIndex].has(boundaryIndex)) {
+        return;
+      }
+      const request = requests[cursor.lineIndex];
+      const prefix = request.line.slice(0, boundariesByLine[cursor.lineIndex][boundaryIndex]).replaceAll('\t', () => ' '.repeat(request.tabSize));
+      pending.set(`${cursor.lineIndex}:${boundaryIndex}`, {
+        boundaryIndex,
+        lineIndex: cursor.lineIndex,
+        text: prefix
+      });
+    };
+    const updateCursor = cursor => {
+      if (cursor.low >= cursor.high) {
+        return;
+      }
+      const middle = Math.floor((cursor.low + cursor.high) / 2);
+      const measured = measurementsByLine[cursor.lineIndex].get(middle);
+      if (measured === undefined) {
+        return;
+      }
+      if (cursor.isStart ? measured <= cursor.target : measured < cursor.target) {
+        cursor.low = middle + 1;
       } else {
-        high = middle;
+        cursor.high = middle;
+      }
+    };
+    while (cursors.some(({
+      high,
+      low
+    }) => low < high)) {
+      const pending = new Map();
+      for (const cursor of cursors) {
+        addPendingMeasurement(cursor, pending);
+      }
+      if (pending.size > 0) {
+        const entries = pending.values().toArray();
+        const measuredWidths = await measureWidths(entries.map(({
+          text
+        }) => text));
+        if (measuredWidths.length !== entries.length) {
+          throw new Error('Text measurement returned an unexpected number of widths');
+        }
+        for (let i = 0; i < entries.length; i++) {
+          const {
+            boundaryIndex,
+            lineIndex
+          } = entries[i];
+          measurementsByLine[lineIndex].set(boundaryIndex, measuredWidths[i]);
+        }
+      }
+      for (const cursor of cursors) {
+        updateCursor(cursor);
       }
     }
-    return Math.min(boundaries.length - 1, low);
-  };
-  try {
-    const startBoundary = await findGreatestBoundaryAtMost(scrollOffset);
-    const endBoundary = await findFirstBoundaryAtLeast(scrollOffset + viewportWidth);
-    const start = boundaries[startBoundary];
-    let end = boundaries[endBoundary];
-    if (end < line.length) {
-      end = boundaries[Math.min(boundaries.length - 1, endBoundary + 1)];
+    for (let lineIndex = 0; lineIndex < boundariesByLine.length; lineIndex++) {
+      const boundaries = boundariesByLine[lineIndex];
+      if (!boundaries) {
+        continue;
+      }
+      const request = requests[lineIndex];
+      const lineCursors = cursors.filter(cursor => cursor.lineIndex === lineIndex);
+      const startBoundary = Math.max(0, lineCursors[0].low - 1);
+      const endBoundary = Math.min(boundaries.length - 1, lineCursors[1].low);
+      const start = boundaries[startBoundary];
+      let end = boundaries[endBoundary];
+      if (end < request.line.length) {
+        end = boundaries[Math.min(boundaries.length - 1, endBoundary + 1)];
+      }
+      const scrollOffset = Math.max(0, Number.isFinite(request.deltaX) ? request.deltaX : 0);
+      results[lineIndex] = {
+        difference: (measurementsByLine[lineIndex].get(startBoundary) ?? 0) - scrollOffset,
+        end,
+        start
+      };
     }
-    return {
-      difference: (await measureBoundary(startBoundary)) - scrollOffset,
-      end,
-      start
-    };
   } catch {
-    return fallback();
+    // Keep the existing approximate range fallback when worker measurement fails.
   }
+  return results;
 };
 const getHorizontalVisibleDifference = (line, start, deltaX, averageCharWidth, tabSize) => {
   const charWidth = averageCharWidth > 0 ? averageCharWidth : 1;
@@ -2953,6 +3008,10 @@ const measureTextWidthSlow = async (text, fontWeight, fontSize, fontFamily, lett
   return width;
 };
 
+const measureTextWidthsSlow = async (texts, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
+  return await invoke$e('TextMeasurement.measureTextWidths', texts, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, 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
@@ -2963,6 +3022,29 @@ const measureTextWidth = async (text, fontWeight, fontSize, fontFamily, letterSp
   }
   return await measureTextWidthSlow(text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth);
 };
+const measureTextWidths = async (texts, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
+  const widths = Array.from({
+    length: texts.length
+  }, (_, index) => index);
+  const slowTexts = [];
+  const slowIndexes = [];
+  for (let i = 0; i < texts.length; i++) {
+    const text = texts[i];
+    if (isMonoSpaceFont && isAscii(text)) {
+      widths[i] = await measureTextWidthFast(text, charWidth);
+    } else {
+      slowTexts.push(text);
+      slowIndexes.push(i);
+    }
+  }
+  if (slowTexts.length > 0) {
+    const slowWidths = await measureTextWidthsSlow(slowTexts, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth);
+    for (let i = 0; i < slowWidths.length; i++) {
+      widths[slowIndexes[i]] = slowWidths[i];
+    }
+  }
+  return widths;
+};
 
 const Dot = '.';
 const DoubleQuote$1 = '"';
@@ -3487,10 +3569,18 @@ const getLineInfosViewport = async (editor, tokens, embeddedResults, minLineY, m
   const tokenMap = get$5(languageId);
   let offset = minLineOffset;
   const tabSize = editor.tabSize ?? 2;
+  const measuredRanges = await getHorizontalVisibleRangesMeasured(lines.slice(minLineY, maxLineY).map(line => ({
+    averageCharWidth,
+    deltaX,
+    line,
+    tabSize,
+    threshold: horizontalVirtualizationThreshold,
+    width
+  })), texts => measureTextWidths(texts, editor.fontWeight, editor.fontSize, editor.fontFamily, editor.letterSpacing, editor.isMonospaceFont, editor.charWidth));
   for (let i = minLineY; i < maxLineY; i++) {
     const line = lines[i];
     const normalize = shouldNormalizeText(line);
-    const measuredRange = await getHorizontalVisibleRangeMeasured(line, deltaX, width, averageCharWidth, tabSize, horizontalVirtualizationThreshold, text => measureTextWidth(text, editor.fontWeight, editor.fontSize, editor.fontFamily, editor.letterSpacing, editor.isMonospaceFont, editor.charWidth));
+    const measuredRange = measuredRanges[i - minLineY];
 
     // Use decorations that were pre-computed (includes links and diagnostics)
     // Filter decorations to only include those for this line

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/editor-worker",
-  "version": "19.72.5",
+  "version": "19.72.6",
   "repository": {
     "type": "git",
     "url": "git@github.com:lvce-editor/editor-worker.git"