@lvce-editor/editor-worker 19.72.4 → 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
@@ -5627,7 +5717,7 @@ const FocusFindWidgetToggleReplace = 42;
 const SourceActions = 38;
 const FocusCodeGenerator = 52;
 
-const createEditor2 = (id, uri, x, y, width, height, platform, assetDir, _languageId, _tokenizePath, _useCache, applicationId) => {
+const createEditor2 = (id, uri, x, y, width, height, platform, assetDir, _languageId, _tokenizePath, _useCache, applicationId, editorFileCacheEnabled = false) => {
   number(id);
   const editor = {
     ...(applicationId !== undefined && {
@@ -5654,6 +5744,7 @@ const createEditor2 = (id, uri, x, y, width, height, platform, assetDir, _langua
     differences: [],
     documentSymbols: [],
     dragAndDropEnabled: true,
+    editorFileCacheEnabled,
     embeds: [],
     endOfLine: 'lf',
     endOfLineDecorations: [],
@@ -16742,11 +16833,78 @@ const intialize = async (syntaxHighlightingEnabled, syncIncremental) => {
 };
 
 const largeFileContentLength = 10 * 1024 * 1024;
+const editorFileCacheMaxBytes = 500_000;
 const pendingFileReads = new Map();
-const readFile = (applicationId, uri, forceReload) => {
+const getFileStatFingerprint = stat => {
+  if (!stat || typeof stat !== 'object' || !Number.isFinite(stat.size)) {
+    return '';
+  }
+  const modifiedTime = stat.mtimeMs ?? stat.mtime;
+  if (typeof modifiedTime !== 'number' && typeof modifiedTime !== 'string') {
+    return '';
+  }
+  const fingerprint = [stat.type, stat.size, modifiedTime];
+  const changedTime = stat.ctimeMs ?? stat.ctime;
+  if (typeof changedTime === 'number' || typeof changedTime === 'string') {
+    fingerprint.push(changedTime);
+  }
+  if (typeof stat.etag === 'string') {
+    fingerprint.push(stat.etag);
+  }
+  return JSON.stringify(fingerprint);
+};
+const isExcludedFromFileCache = uri => {
+  const path = uri.split(/[?#]/, 1)[0];
+  const fileName = path.slice(path.lastIndexOf('/') + 1);
+  return fileName === '.env' || fileName.startsWith('.env.');
+};
+const removeCachedEditorFile = (applicationId, uri) => {
+  void invoke$9(undefined, 'CacheStorage.removeEditorFileCache', applicationId || '', uri).catch(() => {});
+};
+const readFileWithCache = async (applicationId, uri, forceReload, useCache) => {
+  if (!useCache) {
+    return readFile$1(applicationId, uri);
+  }
   if (forceReload) {
+    removeCachedEditorFile(applicationId, uri);
+    return readFile$1(applicationId, uri);
+  }
+  if (isExcludedFromFileCache(uri)) {
+    removeCachedEditorFile(applicationId, uri);
     return readFile$1(applicationId, uri);
   }
+  let fingerprint = '';
+  try {
+    const stat = await invoke$9(applicationId, 'FileSystem.statWithMetadata', uri);
+    if (stat?.size <= editorFileCacheMaxBytes) {
+      fingerprint = getFileStatFingerprint(stat);
+    }
+  } catch {
+    // Filesystems without stat metadata continue to use normal reads.
+  }
+  if (!fingerprint) {
+    removeCachedEditorFile(applicationId, uri);
+  }
+  if (fingerprint) {
+    try {
+      const cached = await invoke$9(undefined, 'CacheStorage.getEditorFileCache', applicationId || '', uri, fingerprint);
+      if (typeof cached === 'string') {
+        return cached;
+      }
+    } catch {
+      // Cache Storage failures must not prevent opening a file.
+    }
+  }
+  const content = await readFile$1(applicationId, uri);
+  if (fingerprint && new TextEncoder().encode(content).byteLength <= editorFileCacheMaxBytes) {
+    void invoke$9(undefined, 'CacheStorage.setEditorFileCache', applicationId || '', uri, fingerprint, content).catch(() => {});
+  }
+  return content;
+};
+const readFile = (applicationId, uri, forceReload, useCache) => {
+  if (forceReload) {
+    return readFileWithCache(applicationId, uri, forceReload, useCache);
+  }
   let applicationReads = pendingFileReads.get(applicationId);
   if (!applicationReads) {
     applicationReads = new Map();
@@ -16768,7 +16926,7 @@ const readFile = (applicationId, uri, forceReload) => {
   };
   fileRead = (async () => {
     try {
-      return await readFile$1(applicationId, uri);
+      return await readFileWithCache(applicationId, uri, forceReload, useCache);
     } finally {
       removePendingRead();
     }
@@ -16927,7 +17085,7 @@ const loadContent = async (state, savedState, largeFile = false, focus = true, f
   let endOfLine = existingEditor?.endOfLine || 'lf';
   try {
     if (!existingEditor) {
-      content = await readFile(state.applicationId, uri, forceReload);
+      content = await readFile(state.applicationId, uri, forceReload, state.editorFileCacheEnabled === true);
       endOfLine = getEndOfLine(content);
       content = normalizeLineEndings(content);
     }

package/package.json

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