@lvce-editor/editor-worker 19.72.3 → 19.72.5

package/dist/editorWorkerMain.js

@@ -5445,7 +5445,7 @@ const mergeConflictsEqual$1 = (oldState, newState) => {
     return conflict.startRowIndex === other.startRowIndex && conflict.endRowIndex === other.endRowIndex;
   });
 };
-const updateDerivedState = async (oldState, newState) => {
+const updateDerivedState = async (oldState, newState, deferGutterDecorations = false) => {
   const horizontalState = oldState.initial || oldState.lines !== newState.lines || oldState.width !== newState.width || oldState.charWidth !== newState.charWidth || oldState.fontFamily !== newState.fontFamily || oldState.fontSize !== newState.fontSize || oldState.fontWeight !== newState.fontWeight || oldState.isMonospaceFont !== newState.isMonospaceFont || oldState.letterSpacing !== newState.letterSpacing || oldState.tabSize !== newState.tabSize || oldState.lineNumbers !== newState.lineNumbers || oldState.breakPoints !== newState.breakPoints || oldState.gutterDecorations !== newState.gutterDecorations || oldState.lightBulbRowIndex !== newState.lightBulbRowIndex ? await updateHorizontalLayout(newState) : newState;
   const layoutState = oldState.lines !== newState.lines && 'foldingRanges' in newState ? updateLayout(horizontalState, []) : horizontalState;
   const nextState = mergeConflictsEqual$1(oldState, layoutState) ? layoutState : {
@@ -5513,7 +5513,7 @@ const updateDerivedState = async (oldState, newState) => {
       lightBulbRowIndex: await getLightBulbRowIndex(finalState)
     };
   }
-  if (oldState.lines !== nextState.lines || oldState.uri !== nextState.uri) {
+  if (!deferGutterDecorations && (oldState.lines !== nextState.lines || oldState.uri !== nextState.uri)) {
     finalState = {
       ...finalState,
       gutterDecorations: await getEditorGutterDecorations(finalState)
@@ -5627,7 +5627,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 +5654,7 @@ const createEditor2 = (id, uri, x, y, width, height, platform, assetDir, _langua
     differences: [],
     documentSymbols: [],
     dragAndDropEnabled: true,
+    editorFileCacheEnabled,
     embeds: [],
     endOfLine: 'lf',
     endOfLineDecorations: [],
@@ -6259,7 +6260,7 @@ const run = async (uid, token, save) => {
   }
   await save(token);
 };
-const schedule = (uid, save) => {
+const schedule$1 = (uid, save) => {
   dispose$4(uid);
   const token = ++state$7.nextToken;
   const timeout = setTimeout(run, autoSaveDelay, uid, token, save);
@@ -7900,6 +7901,70 @@ const editorDiagnosticEffect = {
   isActive: (oldEditor, newEditor) => !oldEditor.initial && !newEditor.loadError && newEditor.diagnosticsEnabled && (oldEditor.lines !== newEditor.lines || oldEditor.languageId !== newEditor.languageId)
 };
 
+const refreshes = new WeakMap();
+const isCurrent = (editor, snapshot) => Boolean(editor && editor.lifecycle === snapshot.lifecycle && !editor.lifecycle?.disposed && editor.lines === snapshot.lines && editor.gutterDecorations === snapshot.gutterDecorations && editor.uri === snapshot.uri && editor.languageId === snapshot.languageId && editor.applicationId === snapshot.applicationId);
+const refresh = async request => {
+  try {
+    while (request.pending) {
+      const snapshot = request.pending;
+      request.pending = undefined;
+      if (snapshot.lifecycle?.disposed) {
+        continue;
+      }
+      const gutterDecorations = await getEditorGutterDecorations(snapshot);
+      const changed = await enqueue(snapshot.uid, async () => {
+        const current = get$8(snapshot.uid)?.newState;
+        if (!isCurrent(current, snapshot) || current.gutterDecorations.length === gutterDecorations.length && gutterDecorations.every((item, index) => item.rowIndex === current.gutterDecorations[index].rowIndex && item.type === current.gutterDecorations[index].type)) {
+          return false;
+        }
+        const next = await updateDerivedState(current, {
+          ...current,
+          gutterDecorations
+        });
+        // Derived state may await layout RPCs while an asynchronous render consumes the baseline.
+        const latest = get$8(snapshot.uid);
+        if (!isCurrent(latest?.newState, snapshot)) {
+          return false;
+        }
+        set$a(snapshot.uid, latest.oldState, next);
+        return true;
+      });
+      if (changed) {
+        await invoke$d('Editor.renderPending', snapshot.uid);
+      }
+    }
+  } catch (error) {
+    console.warn('Failed to refresh gutter decorations:', error);
+  } finally {
+    request.running = false;
+    if (request.pending) {
+      request.running = true;
+      void refresh(request);
+    }
+  }
+};
+const schedule = editor => {
+  const {
+    lifecycle
+  } = editor;
+  if (!lifecycle || lifecycle.disposed) {
+    return;
+  }
+  let request = refreshes.get(lifecycle);
+  if (!request) {
+    request = {
+      pending: undefined,
+      running: false
+    };
+    refreshes.set(lifecycle, request);
+  }
+  request.pending = editor;
+  if (!request.running) {
+    request.running = true;
+    void refresh(request);
+  }
+};
+
 const cursorUndoLimit = 100;
 const selectionsEqual = (left, right) => {
   if (left === right) {
@@ -7983,7 +8048,8 @@ const wrapCommand$1 = (fn, preservesTypingCoalescing = false, returnState = true
     if (state === newEditor) {
       return returnState ? newEditor : undefined;
     }
-    const newEditorWithDerivedState = await updateDerivedState(state, newEditor);
+    const deferGutterDecorations = !initial && uri === newEditor.uri && lines !== newEditor.lines && Boolean(newEditor.lifecycle);
+    const newEditorWithDerivedState = await updateDerivedState(state, newEditor, deferGutterDecorations);
     // Another command can commit before the renderer consumes this edit.
     // Keep its last rendered baseline, including renders completed while we awaited derived state.
     const renderedState = get$8(uid)?.oldState ?? oldInstance.oldState;
@@ -7993,6 +8059,9 @@ const wrapCommand$1 = (fn, preservesTypingCoalescing = false, returnState = true
       void editorDiagnosticEffect.apply(newEditorWithDerivedState);
     }
     const finalEditor = newEditorWithDerivedState;
+    if (deferGutterDecorations) {
+      schedule(finalEditor);
+    }
     await notifyEditorStatusChange(state, finalEditor);
     if (!initial && uri === finalEditor.uri && (endOfLine !== finalEditor.endOfLine || insertSpaces !== finalEditor.insertSpaces || lines !== finalEditor.lines || modified !== finalEditor.modified || redoStack !== finalEditor.redoStack || undoStack !== finalEditor.undoStack)) {
       for (const key of getKeys$2()) {
@@ -8015,15 +8084,18 @@ const wrapCommand$1 = (fn, preservesTypingCoalescing = false, returnState = true
           redoStack: finalEditor.redoStack,
           undoStack: finalEditor.undoStack,
           visualDecorations: finalEditor.visualDecorations
-        });
+        }, deferGutterDecorations);
         set$a(otherUid, instance.oldState, synchronizedEditor);
+        if (deferGutterDecorations) {
+          schedule(synchronizedEditor);
+        }
         if (editorDiagnosticEffect.isActive(editor, synchronizedEditor)) {
           void editorDiagnosticEffect.apply(synchronizedEditor);
         }
       }
     }
     if (lines !== finalEditor.lines && !isUntitledFile(finalEditor.uri)) {
-      schedule(uid, token => saveAfterDelay(uid, token));
+      schedule$1(uid, token => saveAfterDelay(uid, token));
     } else if (modified && !finalEditor.modified) {
       dispose$4(uid);
     }
@@ -16671,11 +16743,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();
@@ -16697,7 +16836,7 @@ const readFile = (applicationId, uri, forceReload) => {
   };
   fileRead = (async () => {
     try {
-      return await readFile$1(applicationId, uri);
+      return await readFileWithCache(applicationId, uri, forceReload, useCache);
     } finally {
       removePendingRead();
     }
@@ -16856,7 +16995,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.3",
+  "version": "19.72.5",
   "repository": {
     "type": "git",
     "url": "git@github.com:lvce-editor/editor-worker.git"