@lvce-editor/main-area-worker 9.68.3 → 9.69.1

package/dist/mainAreaWorkerMain.js

@@ -974,6 +974,9 @@ const logError = () => {
   // handled by renderer worker
 };
 const handleMessage = event => {
+  if (event.data === 'ready') {
+    return Promise.resolve();
+  }
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
   const actualExecute = event?.target?.execute || execute;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
@@ -1466,55 +1469,55 @@ const SetPatches = 'Viewlet.setPatches';
 const FocusEditorText = 12;
 
 const {
-  invoke: invoke$7,
+  invoke: invoke$8,
   set: set$7
 } = create$3(ClipBoardWorker);
 const writeText = async text => {
-  return invoke$7('ClipBoard.writeText', text);
+  return invoke$8('ClipBoard.writeText', text);
 };
 
 const {
-  invoke: invoke$6,
+  invoke: invoke$7,
   set: set$6
 } = create$3(DialogWorker);
 
 const {
-  invoke: invoke$5,
+  invoke: invoke$6,
   set: set$5
 } = create$3(DragAndDropWorker);
 const getDroppedItemsByDropId = async (dropId, isElectron) => {
-  return invoke$5('DragAndDrop.getDroppedItemsByDropId', dropId, isElectron);
+  return invoke$6('DragAndDrop.getDroppedItemsByDropId', dropId, isElectron);
 };
 
 const {
-  invoke: invoke$4,
+  invoke: invoke$5,
   set: set$4
 } = create$3(IconThemeWorker);
 const getIcons = async iconRequests => {
   // @ts-ignore
-  return invoke$4('IconTheme.getIcons', iconRequests);
+  return invoke$5('IconTheme.getIcons', iconRequests);
 };
 
 const {
-  invoke: invoke$3,
+  invoke: invoke$4,
   invokeAndTransfer: invokeAndTransfer$2,
   set: set$3
 } = create$3(RendererProcess);
 
 const {
-  invoke: invoke$2,
+  invoke: invoke$3,
   invokeAndTransfer: invokeAndTransfer$1,
   set: set$2
 } = create$3(RendererWorker);
 const handleModifiedStatusChange$1 = async (uri, modified) => {
-  return invoke$2('Main.handleModifiedStatusChange', uri, modified);
+  return invoke$3('Main.handleModifiedStatusChange', uri, modified);
 };
 const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(uid);
   number(menuId);
   number(x);
   number(y);
-  await invoke$2('ContextMenu.show2', uid, menuId, x, y, args);
+  await invoke$3('ContextMenu.show2', uid, menuId, x, y, args);
 };
 const sendMessagePortToClipBoardWorker$1 = async (port, rpcId) => {
   const command = 'ClipBoard.handleMessagePort';
@@ -1529,14 +1532,32 @@ const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
   await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
 };
 const readFile = async uri => {
-  return invoke$2('FileSystem.readFile', uri);
+  return invoke$3('FileSystem.readFile', uri);
 };
 const confirm = async (message, options) => {
-  const result = await invoke$2('ConfirmPrompt.prompt', message, options);
+  const result = await invoke$3('ConfirmPrompt.prompt', message, options);
   return result;
 };
 const getPreference = async key => {
-  return await invoke$2('Preferences.get', key);
+  return await invoke$3('Preferences.get', key);
+};
+
+const state$2 = {};
+const send$2 = async port => {
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToCacheWorker', port);
+};
+const initialize$2 = async () => {
+  state$2.rpc = await create$6({
+    commandMap: {},
+    isMessagePortOpen: false,
+    send: send$2
+  });
+};
+const invoke$2 = async (command, ...args) => {
+  if (!state$2.rpc) {
+    throw new Error('Cache worker is not initialized');
+  }
+  return state$2.rpc.invoke(command, ...args);
 };
 
 const cacheName = 'lvce0main-area-tabs';
@@ -1574,22 +1595,24 @@ const isClosedTabEntry = value => {
   return Boolean(entry.group && typeof entry.group === 'object' && entry.tab && typeof entry.tab === 'object' && typeof entry.groupIndex === 'number' && typeof entry.tabIndex === 'number');
 };
 const getEntries = async key => {
-  const cache = await caches.open(cacheName);
-  const response = await cache.match(key);
-  const entries = response ? await response.json() : [];
+  const item = await invoke$2('Cache.getCacheStorageItem', key, cacheName);
+  const entries = item ? JSON.parse(new TextDecoder().decode(item.body)) : [];
   return Array.isArray(entries) ? entries.filter(isClosedTabEntry) : [];
 };
 const setEntries = async (key, entries) => {
-  const cache = await caches.open(cacheName);
   const value = JSON.stringify(entries);
   const expires = new Date(Date.now() + cacheDuration).toUTCString();
-  await cache.put(key, new Response(value, {
-    headers: {
-      'Content-Length': String(value.length),
-      'Content-Type': 'application/json',
-      Expires: expires
-    }
-  }));
+  const result = await invoke$2('Cache.setCacheStorageItem', key, value, cacheName, {
+    'Content-Length': String(value.length),
+    'Content-Type': 'application/json',
+    Expires: expires
+  });
+  if (!result?.success) {
+    throw new Error('Failed to store closed tab history');
+  }
+};
+const removeEntries = async key => {
+  return await invoke$2('Cache.removeCacheStorageItem', key, cacheName);
 };
 const compact = entry => {
   return {
@@ -1618,7 +1641,7 @@ const add = (uid, entries) => {
 const clear = uid => {
   return run(uid, async () => {
     try {
-      await setEntries(getKey(uid), []);
+      await removeEntries(getKey(uid));
     } catch {
       // Closed tab history is optional and must never break workspace changes.
     }
@@ -1631,9 +1654,17 @@ const takeLast = uid => {
       const entries = await getEntries(key);
       const entry = entries.at(-1);
       if (!isClosedTabEntry(entry)) {
+        await removeEntries(key);
         return undefined;
       }
-      await setEntries(key, entries.slice(0, -1));
+      if (entries.length === 1) {
+        const removed = await removeEntries(key);
+        if (!removed) {
+          return undefined;
+        }
+      } else {
+        await setEntries(key, entries.slice(0, -1));
+      }
       return entry;
     } catch {
       return undefined;
@@ -1766,16 +1797,16 @@ const closeTab = (state, groupId, tabId) => {
 const handleAttach = async command => {
   // TODO find a better way to append editors
   const parentNodeSelector = '.EditorGroupsContainer, .EditorGroup';
-  await invoke$2('Layout.attachViewlet', parentNodeSelector, command.instanceId);
+  await invoke$3('Layout.attachViewlet', parentNodeSelector, command.instanceId);
 };
 
 const invoke$1 = async (applicationId, method, ...args) => {
-  return applicationId === undefined ? invoke$2(method, ...args) : invoke$2('Application.execute', applicationId, method, ...args);
+  return applicationId === undefined ? invoke$3(method, ...args) : invoke$3('Application.execute', applicationId, method, ...args);
 };
 
 const getViewletTitle = async editorUid => {
   try {
-    const title = await invoke$2('Viewlet.getTitle', editorUid);
+    const title = await invoke$3('Viewlet.getTitle', editorUid);
     return typeof title === 'string' && title ? title : undefined;
   } catch {
     return undefined;
@@ -2228,17 +2259,17 @@ const handleCreate = async command => {
 const handleDetach = async command => {
   // Hides viewlet but keeps it alive
 
-  await invoke$2('Viewlet.detach', command.instanceId);
+  await invoke$3('Viewlet.detach', command.instanceId);
 };
 
 const handleDispose = async command => {
   // Fully destroys viewlet
 
-  await invoke$2('Viewlet.dispose', command.instanceId);
+  await invoke$3('Viewlet.dispose', command.instanceId);
 };
 
 const handleSetBounds = async command => {
-  await invoke$2('Viewlet.setBounds', command.instanceId, command.bounds);
+  await invoke$3('Viewlet.setBounds', command.instanceId, command.bounds);
 };
 
 const executeViewletCommand = async command => {
@@ -2326,17 +2357,17 @@ const saveEditor = async (editorUid, skipFormatting = false) => {
   const args = skipFormatting ? [editorUid, true] : [editorUid];
   const rpc = get$2(RendererWorker);
   if (legacyRenderers.has(rpc)) {
-    return invoke$2('Editor.save', ...args);
+    return invoke$3('Editor.save', ...args);
   }
   try {
-    return await invoke$2('Viewlet.save', ...args);
+    return await invoke$3('Viewlet.save', ...args);
   } catch (error) {
     // Older renderers support only text editors. Never retry an actual save failure.
     if (!(error instanceof Error) || !['Command not found Viewlet.save', 'Command "Viewlet.save" not found (renderer worker)'].includes(error.message)) {
       throw error;
     }
     legacyRenderers.add(rpc);
-    return invoke$2('Editor.save', ...args);
+    return invoke$3('Editor.save', ...args);
   }
 };
 
@@ -2367,7 +2398,7 @@ const promptSave = async title => {
     title: 'Save Changes'
   };
   try {
-    const result = await invoke$2('ConfirmPrompt.prompt3', message, options);
+    const result = await invoke$3('ConfirmPrompt.prompt3', message, options);
     if (['cancel', 'discard', 'save'].includes(result)) {
       return result;
     }
@@ -2378,7 +2409,7 @@ const promptSave = async title => {
     }
   }
   try {
-    const result = await invoke$6('ConfirmPrompt.prompt3', message, options);
+    const result = await invoke$7('ConfirmPrompt.prompt3', message, options);
     if (['cancel', 'discard', 'save'].includes(result)) {
       return result;
     }
@@ -2451,7 +2482,7 @@ const disposeEditors = async editorUids => {
   // Dispose all child viewlets in the renderer worker
   for (const editorUid of editorUids) {
     try {
-      await invoke$2('Viewlet.dispose', editorUid);
+      await invoke$3('Viewlet.dispose', editorUid);
     } catch {
       // Silently ignore errors during disposal
       // Viewlet may already be disposed or renderer worker may not be available
@@ -2762,7 +2793,7 @@ const copyIntoNewWindow$1 = async state => {
   if (!tab?.uri) {
     return state;
   }
-  await invoke$2('ElectronWindow.openNewWithUri', tab.uri);
+  await invoke$3('ElectronWindow.openNewWithUri', tab.uri);
   return state;
 };
 
@@ -2890,7 +2921,7 @@ const isConnected = () => {
   return connected;
 };
 const invoke = (method, ...params) => {
-  return invoke$3(method, ...params);
+  return invoke$4(method, ...params);
 };
 const invokeAndTransfer = (method, ...params) => {
   return invokeAndTransfer$2(method, ...params);
@@ -2906,22 +2937,14 @@ const focus = async state => {
   if (typeof editorUid !== 'number' || editorUid < 0) {
     return state;
   }
-  if (activeTab?.tab.uri?.startsWith('search-editor://')) {
-    if (isConnected()) {
-      await invoke$1(state.applicationId, 'Layout.renderMainAreaPending', state.uid);
-      await invoke('Viewlet.focus', editorUid);
-    } else {
-      await invoke$2('Viewlet.focus', editorUid);
-    }
-    return state;
-  }
-  const selector = activeTab?.tab.terminal ? '.xterm-helper-textarea' : '[name="editor"]';
+  const editorSelector = activeTab?.tab.terminal ? '.xterm-helper-textarea' : '[name="editor"]';
+  const selector = activeTab?.tab.uri?.startsWith('search-editor://') ? '[name="SearchValue"]' : editorSelector;
   if (isConnected()) {
     await invoke$1(state.applicationId, 'Layout.renderMainAreaPending', state.uid);
     await invoke('Viewlet.focusSelector', editorUid, selector);
     await invoke('Viewlet.focusSelectorAfterRender', editorUid, selector);
   } else {
-    await invoke$2('Viewlet.focusSelector', editorUid, selector);
+    await invoke$3('Viewlet.focusSelector', editorUid, selector);
   }
   return state;
 };
@@ -6523,7 +6546,7 @@ const parseTerminalDrag = strings => {
 };
 const receiveTerminal = async (context, drag, targetGroupId) => {
   const initial = context.getState();
-  const descriptor = await invoke$2('TerminalTransfer.takePanelTerminal', initial.uid, drag.sourceUid, drag.terminalUid);
+  const descriptor = await invoke$3('TerminalTransfer.takePanelTerminal', initial.uid, drag.sourceUid, drag.terminalUid);
   if (!descriptor) {
     return;
   }
@@ -6550,11 +6573,11 @@ const receiveTerminal = async (context, drag, targetGroupId) => {
     });
     const location = findTabById(state, tabId);
     const bounds = getSelectedTabBounds(state, location.groupId);
-    await invoke$2('TerminalTransfer.resize', drag.terminalUid, bounds);
+    await invoke$3('TerminalTransfer.resize', drag.terminalUid, bounds);
     await context.updateState(() => state);
     await invoke$1(state.applicationId, 'Layout.renderMainAreaPending', state.uid);
     await focus(state);
-    await invoke$2('TerminalTransfer.commit', drag.terminalUid, initial.uid);
+    await invoke$3('TerminalTransfer.commit', drag.terminalUid, initial.uid);
   } catch (error) {
     if (tabId !== -1) {
       await context.updateState(state => {
@@ -6565,7 +6588,7 @@ const receiveTerminal = async (context, drag, targetGroupId) => {
     try {
       await invoke$1(initial.applicationId, 'Layout.renderMainAreaPending', initial.uid);
     } finally {
-      await invoke$2('TerminalTransfer.rollback', drag.terminalUid);
+      await invoke$3('TerminalTransfer.rollback', drag.terminalUid);
     }
     throw error;
   }
@@ -6577,7 +6600,7 @@ const releaseTerminal = async (context, terminalUid, panelUid) => {
   if (!group || !tab) {
     return;
   }
-  const accepted = await invoke$2('TerminalTransfer.beginPanelTransfer', state.uid, panelUid, terminalUid);
+  const accepted = await invoke$3('TerminalTransfer.beginPanelTransfer', state.uid, panelUid, terminalUid);
   if (!accepted) {
     return;
   }
@@ -6585,9 +6608,9 @@ const releaseTerminal = async (context, terminalUid, panelUid) => {
     await context.updateState(latest => closeTab(latest, group.id, tab.id));
     // Remove the old reference before reparenting the live DOM node.
     await invoke$1(state.applicationId, 'Layout.renderMainAreaPending', state.uid);
-    await invoke$2('TerminalTransfer.attachPanelTerminal', state.uid, panelUid, terminalUid, tab.title, tab.icon);
+    await invoke$3('TerminalTransfer.attachPanelTerminal', state.uid, panelUid, terminalUid, tab.title, tab.icon);
   } catch (error) {
-    const live = await invoke$2('TerminalTransfer.cancelPanelTransfer', terminalUid);
+    const live = await invoke$3('TerminalTransfer.cancelPanelTransfer', terminalUid);
     if (live) {
       await context.updateState(latest => ({
         ...latest,
@@ -7174,7 +7197,7 @@ const handleMessagePort = async (port, viewletCommandMap, setAsRendererProcessFa
       throw new TypeError(`Viewlet command not found: ${command}`);
     }
     await fn(uid, ...args);
-    await invoke$2('Viewlet.requestRender', uid);
+    await invoke$3('Viewlet.requestRender', uid);
   };
   const rpc = await create$8({
     commandMap: {
@@ -7223,7 +7246,7 @@ const handleModifiedStatusChangeWithContext = async (context, uri, newStatus) =>
 
 const resizeChild = async (editorUid, dimensions) => {
   try {
-    return await invoke$2('Viewlet.resize', editorUid, dimensions);
+    return await invoke$3('Viewlet.resize', editorUid, dimensions);
   } catch {
     return [];
   }
@@ -7565,7 +7588,7 @@ const focusTab = async (state, groupIndex, index) => {
   if (isConnected()) {
     await invoke('Viewlet.focusSelector', state.uid, selector);
   } else {
-    await invoke$2('Viewlet.focusSelector', state.uid, selector);
+    await invoke$3('Viewlet.focusSelector', state.uid, selector);
   }
 };
 const handleTabKeyDown = async (state, groupIndexRaw, indexRaw, key) => {
@@ -7612,7 +7635,7 @@ const handleTabsWheel = async (state, groupIndexRaw, deltaMode, deltaY) => {
   if (isConnected()) {
     await invoke('Viewlet.scrollSelectorBy', state.uid, selector, pixelDelta);
   } else {
-    await invoke$2('Viewlet.scrollSelectorBy', state.uid, selector, pixelDelta);
+    await invoke$3('Viewlet.scrollSelectorBy', state.uid, selector, pixelDelta);
   }
   return state;
 };
@@ -7639,7 +7662,7 @@ const handleUriChange = async (state, oldUri, newUri) => {
         }
         if (renamedUri) {
           if (tab.editorInput?.type === 'editor' && tab.editorUid !== -1) {
-            editorUriUpdates.push(invoke$2('Editor.handleUriChange', tab.editorUid, renamedUri));
+            editorUriUpdates.push(invoke$3('Editor.handleUriChange', tab.editorUid, renamedUri));
           }
           const editorInput = tab.editorInput && 'uri' in tab.editorInput ? {
             ...tab.editorInput,
@@ -8005,7 +8028,7 @@ const reloadChangedEditors = async (state, changed, reloadAll) => {
       }
     }
   }
-  await Promise.allSettled(Array.from(editorUids, editorUid => invoke$2('Viewlet.reload', editorUid)));
+  await Promise.allSettled(Array.from(editorUids, editorUid => invoke$3('Viewlet.reload', editorUid)));
 };
 const handleWorkspaceRefresh = async (state, refresh = {}) => {
   const changes = Array.isArray(refresh) ? {
@@ -8308,12 +8331,12 @@ const moveIntoNewWindow = async state => {
   if (!tab?.uri) {
     return state;
   }
-  await invoke$2('ElectronWindow.openNewWithUri', tab.uri);
+  await invoke$3('ElectronWindow.openNewWithUri', tab.uri);
   return closeTabAndSave(state, group.id, activeTabId);
 };
 
 const newWindow = async state => {
-  await invoke$2('ElectronWindow.openNew');
+  await invoke$3('ElectronWindow.openNew');
   return state;
 };
 
@@ -8573,7 +8596,7 @@ const renderPendingViewletUpdate = (oldState, newState) => {
   const update = newState.pendingViewletUpdate;
   newState.pendingViewletUpdate = undefined;
   setTimeout(() => {
-    void invoke$2('Viewlet.dispose', update.disposal).catch(() => {});
+    void invoke$3('Viewlet.dispose', update.disposal).catch(() => {});
   }, 50);
   return update.focus === undefined ? [] : ['Viewlet.setFocusContext', update.focus, FocusEditorText, 0, update.focus, 'Editor'];
 };
@@ -8808,7 +8831,7 @@ const reopenEditorWith = async (context, preferredEditorId) => {
   await context.updateState(() => readyState);
   if (oldEditorUid !== -1) {
     try {
-      await invoke$2('Viewlet.dispose', oldEditorUid);
+      await invoke$3('Viewlet.dispose', oldEditorUid);
     } catch {
       // Reopening should still proceed if the previous viewlet was already disposed.
     }
@@ -9199,7 +9222,7 @@ const splitEditorGroupAndResize = async (state, split, ...args) => {
   await handleResize(newState, newState);
   const editorUids = newState.layout.groups.flatMap(group => group.tabs.map(tab => tab.editorUid).filter(editorUid => editorUid !== -1));
   for (const editorUid of editorUids) {
-    await invoke$2('Viewlet.requestRender', editorUid);
+    await invoke$3('Viewlet.requestRender', editorUid);
   }
   return newState;
 };
@@ -9256,6 +9279,7 @@ const commandMap = {
   'Main.focusPreviousTab': wrapSerialCommand(focusPreviousTab),
   'Main.handleModifiedStatusChange': wrapAsyncCommand(handleModifiedStatusChangeWithContext),
   'Main.handleTabContextMenu': wrapSerialCommand(handleTabContextMenu),
+  'Main.handleUriChange': wrapAsyncCommand(handleUriChangeWithContext),
   'Main.hasActiveTextEditor': wrapGetter(hasActiveTextEditor),
   'Main.hasDirtyTabs': wrapGetter(hasDirtyTabs),
   'Main.openInput': wrapSerialAsyncCommand(openInputWithContext),
@@ -9435,7 +9459,7 @@ const initializeRendererWorker = async port => {
 
 const listen = async port => {
   registerCommands(commandMap);
-  await Promise.all([initializeRendererWorker(port), initializeIconThemeWorker(), initializeClipBoardWorker(), initializeDragAndDropWorker()]);
+  await Promise.all([initializeRendererWorker(port), initializeIconThemeWorker(), initializeClipBoardWorker(), initializeDragAndDropWorker(), initialize$2()]);
   const dialogRpc = await create$6({
     commandMap: {},
     send: sendMessagePortToDialogWorker

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/main-area-worker",
-  "version": "9.68.3",
+  "version": "9.69.1",
   "description": "Main Area Worker",
   "repository": {
     "type": "git",