@lvce-editor/editor-worker 19.29.6 → 19.29.8

package/dist/editorWorkerMain.js

@@ -1909,12 +1909,12 @@ const launchColorPickerWorker = async () => {
   return launchWorker(name, url);
 };
 
-const state$c = {};
+const state$d = {};
 const getOrCreate$3 = () => {
-  if (!state$c.workerPromise) {
-    state$c.workerPromise = launchColorPickerWorker();
+  if (!state$d.workerPromise) {
+    state$d.workerPromise = launchColorPickerWorker();
   }
-  return state$c.workerPromise;
+  return state$d.workerPromise;
 };
 const invoke$8 = async (method, ...params) => {
   const worker = await getOrCreate$3();
@@ -1941,7 +1941,7 @@ const loadContent$3 = async (state, parentUid) => {
 
 const editorStates = create$9();
 const {
-  dispose: dispose$2,
+  dispose: dispose$3,
   getCommandIds,
   registerCommands,
   wrapGetter
@@ -2476,7 +2476,7 @@ const getInitialLineState = initialLineState => {
   return deepCopy(initialLineState);
 };
 
-const state$b = {
+const state$c = {
   warned: []
 };
 const flattenTokensArray = tokens => {
@@ -2488,10 +2488,10 @@ const flattenTokensArray = tokens => {
   return flattened;
 };
 const warnDeprecatedArrayReturn = (languageId, fn) => {
-  if (state$b.warned.includes(fn)) {
+  if (state$c.warned.includes(fn)) {
     return;
   }
-  state$b.warned.push(fn);
+  state$c.warned.push(fn);
   console.warn(`tokenizers without hasArrayReturn=false are deprecated (language ${languageId})`);
 };
 const safeTokenizeLine = (languageId, tokenizeLine, line, lineStateAtStart, hasArrayReturn) => {
@@ -2552,14 +2552,14 @@ const TokenizePlainText = {
   tokenizeLine
 };
 
-const state$a = {
+const state$b = {
   enabled: false
 };
 const setEnabled$1 = value => {
-  state$a.enabled = value;
+  state$b.enabled = value;
 };
 const getEnabled$1 = () => {
-  return state$a.enabled;
+  return state$b.enabled;
 };
 
 const {
@@ -2567,25 +2567,25 @@ const {
   set: set$6
 } = SyntaxHighlightingWorker;
 
-const state$9 = {
+const state$a = {
   pending: Object.create(null),
   tokenizePaths: Object.create(null),
   tokenizers: Object.create(null)
 };
 const has = languageId => {
-  return Object.hasOwn(state$9.tokenizers, languageId);
+  return Object.hasOwn(state$a.tokenizers, languageId);
 };
 const set$5 = (languageId, tokenizer) => {
-  state$9.tokenizers[languageId] = tokenizer;
+  state$a.tokenizers[languageId] = tokenizer;
 };
 const get$6 = languageId => {
-  return state$9.tokenizers[languageId];
+  return state$a.tokenizers[languageId];
 };
 const setTokenizePath = (languageId, tokenizePath) => {
-  state$9.tokenizePaths[languageId] = tokenizePath;
+  state$a.tokenizePaths[languageId] = tokenizePath;
 };
 const getTokenizePath$1 = languageId => {
-  return state$9.tokenizePaths[languageId] || '';
+  return state$a.tokenizePaths[languageId] || '';
 };
 const setTokenizePaths = languages => {
   for (const language of languages) {
@@ -2595,7 +2595,7 @@ const setTokenizePaths = languages => {
   }
 };
 const isPending = languageId => {
-  return Object.hasOwn(state$9.pending, languageId);
+  return Object.hasOwn(state$a.pending, languageId);
 };
 
 const tokenMaps = Object.create(null);
@@ -3391,14 +3391,14 @@ const getVisible$1 = async (editor, syncIncremental) => {
   };
 };
 
-const state$8 = {
+const state$9 = {
   enabled: false
 };
 const setEnabled = value => {
-  state$8.enabled = value;
+  state$9.enabled = value;
 };
 const getEnabled = () => {
-  return state$8.enabled;
+  return state$9.enabled;
 };
 
 // TODO this should be in a separate scrolling module
@@ -3623,7 +3623,7 @@ const getUrlAtOffset = (editor, offset) => {
 
 const EditorChange = 1;
 
-const state$7 = Object.create(null);
+const state$8 = Object.create(null);
 
 /**
  * Register a listener for a specific event type
@@ -3633,13 +3633,13 @@ const state$7 = Object.create(null);
 const registerListener$1 = (listenerType, rpcId) => {
   number(listenerType);
   number(rpcId);
-  if (!Object.hasOwn(state$7, listenerType)) {
-    state$7[listenerType] = [];
+  if (!Object.hasOwn(state$8, listenerType)) {
+    state$8[listenerType] = [];
   }
 
   // Avoid duplicate registrations
-  if (!state$7[listenerType].includes(rpcId)) {
-    state$7[listenerType].push(rpcId);
+  if (!state$8[listenerType].includes(rpcId)) {
+    state$8[listenerType].push(rpcId);
   }
 };
 
@@ -3651,10 +3651,10 @@ const registerListener$1 = (listenerType, rpcId) => {
 const unregisterListener$1 = (listenerType, rpcId) => {
   number(listenerType);
   number(rpcId);
-  if (Object.hasOwn(state$7, listenerType)) {
-    const index = state$7[listenerType].indexOf(rpcId);
+  if (Object.hasOwn(state$8, listenerType)) {
+    const index = state$8[listenerType].indexOf(rpcId);
     if (index !== -1) {
-      state$7[listenerType].splice(index, 1);
+      state$8[listenerType].splice(index, 1);
     }
   }
 };
@@ -3666,7 +3666,7 @@ const unregisterListener$1 = (listenerType, rpcId) => {
  */
 const getListeners = listenerType => {
   number(listenerType);
-  return state$7[listenerType] || [];
+  return state$8[listenerType] || [];
 };
 
 /**
@@ -4782,6 +4782,44 @@ const diff2 = uid => {
   return result;
 };
 
+const autoSaveDelay = 1000;
+const pendingSaves = new Map();
+const state$7 = {
+  nextToken: 0
+};
+const run = async (uid, token, save) => {
+  if (!isLatest(uid, token)) {
+    return;
+  }
+  await save(token);
+};
+const schedule = (uid, save) => {
+  dispose$2(uid);
+  const token = ++state$7.nextToken;
+  const timeout = setTimeout(run, autoSaveDelay, uid, token, save);
+  pendingSaves.set(uid, {
+    timeout,
+    token
+  });
+};
+const isLatest = (uid, token) => {
+  return pendingSaves.get(uid)?.token === token;
+};
+const consume = (uid, token) => {
+  if (!isLatest(uid, token)) {
+    return;
+  }
+  dispose$2(uid);
+};
+const dispose$2 = uid => {
+  const pendingSave = pendingSaves.get(uid);
+  if (!pendingSave) {
+    return;
+  }
+  clearTimeout(pendingSave.timeout);
+  pendingSaves.delete(uid);
+};
+
 const addWidget$1 = widget => {
   const module = get$7(widget.id);
   if (!module) {
@@ -4874,6 +4912,7 @@ const disposeEditor = async editorUid => {
   });
   dispose$1(editorUid);
   dispose$2(editorUid);
+  dispose$3(editorUid);
   return commands;
 };
 
@@ -7048,16 +7087,19 @@ const goTo = async ({
     return editor;
   } catch (error) {
     // TODO if editor is already disposed at this point, do nothing
+    if (error === null || error === undefined) {
+      const info = getWordAt$1(editor, rowIndex, columnIndex);
+      const message = getNoLocationFoundMessage(info);
+      return editorShowMessage(editor, rowIndex, columnIndex, message);
+    }
     if (isNoProviderFoundError(error)) {
       const displayErrorMessage = getErrorMessage(error);
-      await editorShowMessage(editor, rowIndex, columnIndex, displayErrorMessage);
-      return editor;
+      return editorShowMessage(editor, rowIndex, columnIndex, displayErrorMessage);
     }
     // @ts-ignore
     // ErrorHandling.handleError(error, false)
     const displayErrorMessage = getErrorMessage(error);
-    await editorShowMessage(editor, rowIndex, columnIndex, displayErrorMessage);
-    return editor;
+    return editorShowMessage(editor, rowIndex, columnIndex, displayErrorMessage);
   }
 };
 
@@ -13653,6 +13695,30 @@ const editorDiagnosticEffect = {
 };
 
 const queues = {};
+const saveAfterDelay = async (uid, token) => {
+  if (!get$8(uid)) {
+    consume(uid, token);
+    return;
+  }
+  let didSave = false;
+  const save$1 = wrapCommand(async editor => {
+    if (!isLatest(uid, token)) {
+      return editor;
+    }
+    consume(uid, token);
+    const autoSave = await get$3('files.autoSave');
+    if (autoSave !== 'afterDelay') {
+      return editor;
+    }
+    const savedEditor = await save(editor);
+    didSave = savedEditor !== editor;
+    return savedEditor;
+  });
+  await save$1(uid);
+  if (didSave) {
+    await invoke$a('Editor.renderPending', uid);
+  }
+};
 
 // TODO wrap commands globally, not per editor
 // TODO only store editor state in editor worker, not in renderer worker also
@@ -13717,6 +13783,11 @@ const wrapCommand = fn => async (uid, ...args) => {
         set$8(otherUid, instance.oldState, synchronizedEditor);
       }
     }
+    if (lines !== finalEditor.lines) {
+      schedule(uid, token => saveAfterDelay(uid, token));
+    } else if (modified && !finalEditor.modified) {
+      dispose$2(uid);
+    }
     return finalEditor;
   } finally {
     resolve();

package/package.json

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