@lvce-editor/main-area-worker 4.0.0 → 5.0.0

package/dist/mainAreaWorkerMain.js

@@ -102,14 +102,15 @@ const {
   get: get$2,
   getCommandIds,
   registerCommands,
-  set: set$3,
+  set: set$4,
   wrapCommand,
   wrapGetter
 } = create$7();
 
-const create$6 = (uid, uri, x, y, width, height, platform, assetDir) => {
+const create$6 = (uid, uri, x, y, width, height, platform, assetDir, tabHeight = 35) => {
   const state = {
     assetDir,
+    fileIconCache: {},
     height,
     layout: {
       activeGroupId: undefined,
@@ -117,12 +118,13 @@ const create$6 = (uid, uri, x, y, width, height, platform, assetDir) => {
       groups: []
     },
     platform,
+    tabHeight,
     uid,
     width,
     x,
     y
   };
-  set$3(uid, state, state);
+  set$4(uid, state, state);
 };
 
 const isEqual = (oldState, newState) => {
@@ -154,14 +156,7 @@ const diff2 = uid => {
   return result;
 };
 
-const Button$1 = 1;
-const Div = 4;
-const Span = 8;
-const Text = 12;
-const Img = 17;
-const Pre = 51;
-
-const Button = 'event.button';
+const Button$1 = 'event.button';
 const ClientX = 'event.clientX';
 const ClientY = 'event.clientY';
 const TargetName = 'event.target.name';
@@ -171,9 +166,6 @@ const Tab = 13;
 const Separator = 1;
 const None = 0;
 
-const ExtensionHostWorker = 44;
-const RendererWorker = 1;
-
 const SetDom2 = 'Viewlet.setDom2';
 
 const getMenuIds = () => {
@@ -187,6 +179,10 @@ const handleClick = async (state, name) => {
   return state;
 };
 
+const ExtensionHostWorker = 44;
+const IconThemeWorker = 7009;
+const RendererWorker = 1;
+
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -1152,6 +1148,53 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
+
+/* eslint-disable @typescript-eslint/no-misused-promises */
+
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
+};
+const create$j = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$3({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
+  });
+};
+const LazyTransferMessagePortRpcParent = {
+  __proto__: null,
+  create: create$j
+};
 const create$5 = async ({
   commandMap,
   isMessagePortOpen = true,
@@ -1224,7 +1267,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$2 = (id, rpc) => {
+const set$3 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
@@ -1257,7 +1300,7 @@ const create$1 = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$2(rpcId, mockRpc);
+      set$3(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -1266,15 +1309,24 @@ const create$1 = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$2(rpcId, rpc);
+      set$3(rpcId, rpc);
     }
   };
 };
 
 const {
-  set: set$1
+  set: set$2
 } = create$1(ExtensionHostWorker);
 
+const {
+  invoke: invoke$1,
+  set: set$1
+} = create$1(IconThemeWorker);
+const getIcons = async iconRequests => {
+  // @ts-ignore
+  return invoke$1('IconTheme.getIcons', iconRequests);
+};
+
 const {
   invoke,
   invokeAndTransfer,
@@ -1288,6 +1340,11 @@ const showContextMenu2 = async (uid, menuId, x, y, args) => {
   // @ts-ignore
   await invoke('ContextMenu.show2', uid, menuId, x, y, args);
 };
+const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
+  const command = 'IconTheme.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
+};
 const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
@@ -1498,7 +1555,7 @@ const handleCreate = async command => {
     oldState
   } = get$2(command.uid);
   const readyState = handleViewletReady(state, command.editorUid);
-  set$3(command.uid, oldState, readyState);
+  set$4(command.uid, oldState, readyState);
   return readyState;
 };
 
@@ -1624,6 +1681,30 @@ const handleClickCloseTab = (state, rawGroupIndex, rawIndex) => {
   return closeTab(state, groupId, tabId);
 };
 
+const createViewlet = async (viewletModuleId, editorUid, tabId, bounds, uri) => {
+  // @ts-ignore
+  await invoke('Layout.createViewlet', viewletModuleId, editorUid, tabId, bounds, uri);
+};
+
+const findTabById = (state, tabId) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  for (const group of groups) {
+    const tab = group.tabs.find(t => t.id === tabId);
+    if (tab) {
+      return {
+        groupId: group.id,
+        tab
+      };
+    }
+  }
+  return undefined;
+};
+
 // Counter for request IDs to handle race conditions
 let requestIdCounter = 0;
 const getNextRequestId = () => {
@@ -1635,7 +1716,7 @@ const startContentLoading = async (oldState, state, tabId, path, requestId) => {
     const getLatestState = () => {
       return get$2(state.uid).newState;
     };
-    set$3(state.uid, oldState, state);
+    set$4(state.uid, oldState, state);
     const newState = await loadTabContentAsync(tabId, path, requestId, getLatestState);
     return newState;
   } catch {
@@ -1765,12 +1846,43 @@ const selectTab = async (state, groupIndex, index) => {
         };
         const createdState = createViewletForTab(newState, tabId, viewletModuleId, bounds);
         newState = createdState;
+
+        // Store updated state before creating viewlet
+        set$4(uid, state, newState);
+
+        // Execute viewlet commands if any
+        if (switchCommands.length > 0) {
+          await executeViewletCommands(switchCommands);
+        }
+
+        // Get the tab to extract editorUid for viewlet creation
+        const tabWithViewlet = findTabById(newState, tabId);
+        if (tabWithViewlet) {
+          const {
+            editorUid
+          } = tabWithViewlet.tab;
+          if (editorUid !== -1 && newTab.uri) {
+            // Create the actual viewlet instance
+            await createViewlet(viewletModuleId, editorUid, tabId, bounds, newTab.uri);
+
+            // Mark viewlet as ready
+            newState = handleViewletReady(newState, editorUid);
+            set$4(uid, state, newState);
+          }
+        }
+
+        // Start loading content in the background if needed
+        if (needsLoading && tab.uri) {
+          const latestState = await startContentLoading(state, newState, tabId, tab.uri, requestId);
+          return latestState;
+        }
+        return newState;
       }
     } catch {
       // Viewlet creation is optional - silently ignore if RendererWorker isn't available
     }
   }
-  set$3(uid, state, newState);
+  set$4(uid, state, newState);
 
   // Execute viewlet commands if any
   if (switchCommands.length > 0) {
@@ -1829,12 +1941,7 @@ const createExtensionHostRpc = async () => {
 
 const initialize = async () => {
   const rpc = await createExtensionHostRpc();
-  set$1(rpc);
-};
-
-const createViewlet = async (viewletModuleId, editorUid, tabId, bounds, uri) => {
-  // @ts-ignore
-  await invoke('Layout.createViewlet', viewletModuleId, editorUid, tabId, bounds, uri);
+  set$2(rpc);
 };
 
 const getMaxIdFromLayout = layout => {
@@ -1852,18 +1959,6 @@ const getMaxIdFromLayout = layout => {
   return maxId;
 };
 
-const getViewletModuleId = async uri => {
-  // Query RendererWorker for viewlet module ID (optional, may fail in tests)
-  let viewletModuleId;
-  try {
-    // @ts-ignore
-    viewletModuleId = await invoke('Layout.getModuleId', uri);
-  } catch {
-    // Viewlet creation is optional - silently ignore if RendererWorker isn't available
-  }
-  return viewletModuleId;
-};
-
 const isValidTab = tab => {
   return tab && typeof tab.id === 'number' && typeof tab.title === 'string' && typeof tab.content === 'string' && typeof tab.isDirty === 'boolean' && (tab.editorType === 'text' || tab.editorType === 'custom') && (tab.editorType !== 'custom' || typeof tab.customEditorId === 'string');
 };
@@ -1908,71 +2003,254 @@ const tryRestoreLayout = savedState => {
   return layout;
 };
 
+const getIconsCached = (dirents, fileIconCache) => {
+  return dirents.map(dirent => fileIconCache[dirent]);
+};
+
+const getBasename$1 = uri => {
+  const lastSlashIndex = uri.lastIndexOf('/');
+  if (lastSlashIndex === -1) {
+    return uri;
+  }
+  return uri.slice(lastSlashIndex + 1);
+};
+const getMissingTabs = (tabs, fileIconCache) => {
+  const missingTabs = [];
+  for (const tab of tabs) {
+    if (tab.uri && !(tab.uri in fileIconCache)) {
+      missingTabs.push(tab);
+    }
+  }
+  return missingTabs;
+};
+const tabToIconRequest = tab => {
+  const uri = tab.uri || '';
+  return {
+    name: getBasename$1(uri),
+    path: uri,
+    type: 0 // file type
+  };
+};
+const getMissingIconRequestsForTabs = (tabs, fileIconCache) => {
+  const missingRequests = getMissingTabs(tabs, fileIconCache);
+  const iconRequests = missingRequests.map(tabToIconRequest);
+  return iconRequests;
+};
+
+const Directory = 3;
+const DirectoryExpanded = 4;
+
+const getSimpleIconRequestType = direntType => {
+  if (direntType === Directory || direntType === DirectoryExpanded) {
+    return 2;
+  }
+  return 1;
+};
+
+const toSimpleIconRequest = request => {
+  return {
+    name: request.name,
+    type: getSimpleIconRequestType(request.type)
+  };
+};
+
+const requestFileIcons = async requests => {
+  if (requests.length === 0) {
+    return [];
+  }
+  const simpleRequests = requests.map(toSimpleIconRequest);
+  const icons = await getIcons(simpleRequests);
+  return icons;
+};
+
+const updateIconCache = (iconCache, missingRequests, newIcons) => {
+  if (missingRequests.length === 0) {
+    return iconCache;
+  }
+  const newFileIconCache = {
+    ...iconCache
+  };
+  for (let i = 0; i < missingRequests.length; i++) {
+    const request = missingRequests[i];
+    const icon = newIcons[i];
+    newFileIconCache[request.path] = icon;
+  }
+  return newFileIconCache;
+};
+
+const getFileIconsForTabs = async (tabs, fileIconCache) => {
+  const missingRequests = getMissingIconRequestsForTabs(tabs, fileIconCache);
+  const newIcons = await requestFileIcons(missingRequests);
+  const newFileIconCache = updateIconCache(fileIconCache, missingRequests, newIcons);
+  const tabUris = tabs.map(tab => tab.uri || '');
+  const icons = getIconsCached(tabUris, newFileIconCache);
+  return {
+    icons,
+    newFileIconCache
+  };
+};
+
+const getAllTabs = layout => {
+  const allTabs = [];
+  for (const group of layout.groups) {
+    allTabs.push(...group.tabs);
+  }
+  return allTabs;
+};
+
+const loadFileIcons = async state => {
+  try {
+    const allTabs = getAllTabs(state.layout);
+    const {
+      newFileIconCache
+    } = await getFileIconsForTabs(allTabs, state.fileIconCache);
+
+    // Update tabs with their icons
+    const updatedLayout = {
+      ...state.layout,
+      groups: state.layout.groups.map(group => ({
+        ...group,
+        tabs: group.tabs.map(tab => ({
+          ...tab,
+          icon: newFileIconCache[tab.uri || '']
+        }))
+      }))
+    };
+    return {
+      fileIconCache: newFileIconCache,
+      updatedLayout
+    };
+  } catch {
+    // If icon request fails, continue without icons
+    return {
+      fileIconCache: state.fileIconCache,
+      updatedLayout: state.layout
+    };
+  }
+};
+
+const getViewletModuleId = async uri => {
+  // Query RendererWorker for viewlet module ID (optional, may fail in tests)
+  let viewletModuleId;
+  try {
+    // @ts-ignore
+    viewletModuleId = await invoke('Layout.getModuleId', uri);
+  } catch {
+    // Viewlet creation is optional - silently ignore if RendererWorker isn't available
+  }
+  return viewletModuleId;
+};
+
+const TAB_HEIGHT = 35;
+
+// Get viewlet module IDs for active tabs in each group
+const getViewletModuleIds = async layout => {
+  const viewletModuleIds = {};
+  for (const group of layout.groups) {
+    const activeTab = group.tabs.find(tab => tab.id === group.activeTabId);
+    if (activeTab && activeTab.uri) {
+      const viewletModuleId = await getViewletModuleId(activeTab.uri);
+      if (viewletModuleId) {
+        viewletModuleIds[activeTab.id] = viewletModuleId;
+      }
+    }
+  }
+  return viewletModuleIds;
+};
+
+// Create viewlets for the active tabs
+const createViewlets = async (layout, viewletModuleIds, bounds) => {
+  const editorUids = {};
+  for (const group of layout.groups) {
+    const activeTab = group.tabs.find(tab => tab.id === group.activeTabId);
+    if (activeTab && viewletModuleIds[activeTab.id]) {
+      const editorUid = activeTab.editorUid === -1 ? create() : activeTab.editorUid;
+      editorUids[activeTab.id] = editorUid;
+      await createViewlet(viewletModuleIds[activeTab.id], editorUid, activeTab.id, bounds, activeTab.uri);
+    }
+  }
+  return editorUids;
+};
+
+// Update tabs with editor UIDs
+const updateTabs = (state, editorUids) => {
+  const updatedGroups = state.layout.groups.map(group => {
+    return {
+      ...group,
+      tabs: group.tabs.map(tab => {
+        if (editorUids[tab.id]) {
+          return {
+            ...tab,
+            editorUid: editorUids[tab.id]
+          };
+        }
+        return tab;
+      })
+    };
+  });
+  return {
+    ...state,
+    layout: {
+      ...state.layout,
+      groups: updatedGroups
+    }
+  };
+};
+const restoreAndCreateEditors = async (state, restoredLayout) => {
+  let newState = {
+    ...state,
+    layout: restoredLayout
+  };
+  const bounds = {
+    height: newState.height - TAB_HEIGHT,
+    width: newState.width,
+    x: newState.x,
+    y: newState.y + TAB_HEIGHT
+  };
+
+  // Get viewlet module IDs for all active tabs
+  const viewletModuleIds = await getViewletModuleIds(newState.layout);
+
+  // Create viewlets and get editor UIDs
+  const editorUids = await createViewlets(newState.layout, viewletModuleIds, bounds);
+
+  // Update tabs with editor UIDs
+  newState = updateTabs(newState, editorUids);
+
+  // Create viewlets in the lifecycle and mark them as ready
+  for (const group of newState.layout.groups) {
+    const activeTab = group.tabs.find(tab => tab.id === group.activeTabId);
+    if (activeTab && viewletModuleIds[activeTab.id]) {
+      const editorUid = editorUids[activeTab.id];
+      newState = createViewletForTab(newState, activeTab.id);
+      newState = handleViewletReady(newState, editorUid);
+    }
+  }
+  return newState;
+};
+
 const loadContent = async (state, savedState) => {
   const restoredLayout = tryRestoreLayout(savedState);
   if (restoredLayout) {
     const maxId = getMaxIdFromLayout(restoredLayout);
     setMinId(maxId);
-    let newState = {
-      ...state,
-      layout: restoredLayout
-    };
-
-    // Create viewlets only for active tabs in each group
-    const TAB_HEIGHT = 35;
-    const bounds = {
-      height: newState.height - TAB_HEIGHT,
-      width: newState.width,
-      x: newState.x,
-      y: newState.y + TAB_HEIGHT
-    };
-    for (const group of restoredLayout.groups) {
-      // Find the active tab in this group
-      const activeTab = group.tabs.find(tab => tab.id === group.activeTabId);
-      if (activeTab && activeTab.uri) {
-        const viewletModuleId = await getViewletModuleId(activeTab.uri);
-        if (viewletModuleId) {
-          // Ensure the tab has an editorUid
-          const editorUid = activeTab.editorUid === -1 ? create() : activeTab.editorUid;
-
-          // Create viewlet for the tab
-          newState = createViewletForTab(newState, activeTab.id);
-
-          // Update the tab with the editorUid in the state
-          const updatedGroups = newState.layout.groups.map(g => {
-            if (g.id !== group.id) {
-              return g;
-            }
-            return {
-              ...g,
-              tabs: g.tabs.map(t => {
-                if (t.id !== activeTab.id) {
-                  return t;
-                }
-                return {
-                  ...t,
-                  editorUid
-                };
-              })
-            };
-          });
-          newState = {
-            ...newState,
-            layout: {
-              ...newState.layout,
-              groups: updatedGroups
-            }
-          };
 
-          // Create the actual viewlet instance
-          await createViewlet(viewletModuleId, editorUid, activeTab.id, bounds, activeTab.uri);
+    // Restore and create editors
+    const editorState = await restoreAndCreateEditors(state, restoredLayout);
 
-          // Mark the viewlet as ready
-          newState = handleViewletReady(newState, editorUid);
-        }
-      }
-    }
-    return newState;
+    // Load file icons with the updated editor state
+    const {
+      fileIconCache,
+      updatedLayout
+    } = await loadFileIcons(editorState);
+
+    // Merge the results
+    const finalState = {
+      ...editorState,
+      fileIconCache,
+      layout: updatedLayout
+    };
+    return finalState;
   }
   return {
     ...state,
@@ -2125,6 +2403,7 @@ const createEmptyGroup = (state, uri, requestId) => {
     editorType: 'text',
     editorUid,
     errorMessage: '',
+    icon: '',
     id: tabId,
     isDirty: false,
     language: '',
@@ -2205,6 +2484,7 @@ const ensureActiveGroup = (state, uri) => {
       editorType: 'text',
       editorUid,
       errorMessage: '',
+      icon: '',
       id: tabId,
       isDirty: false,
       language: '',
@@ -2219,25 +2499,6 @@ const ensureActiveGroup = (state, uri) => {
   return newState;
 };
 
-const findTabById = (state, tabId) => {
-  const {
-    layout
-  } = state;
-  const {
-    groups
-  } = layout;
-  for (const group of groups) {
-    const tab = group.tabs.find(t => t.id === tabId);
-    if (tab) {
-      return {
-        groupId: group.id,
-        tab
-      };
-    }
-  }
-  return undefined;
-};
-
 const findTabByUri = (state, uri) => {
   const {
     layout
@@ -2372,7 +2633,7 @@ const openUri = async (state, options) => {
     newState: switchedState
   } = switchViewlet(intermediateState1);
   intermediateState1 = switchedState;
-  set$3(uid, state, intermediateState1);
+  set$4(uid, state, intermediateState1);
 
   // @ts-ignore
 
@@ -2397,6 +2658,36 @@ const openUri = async (state, options) => {
 
   // Attachment is handled automatically by virtual DOM reference nodes
   const readyState = handleViewletReady(latestState, editorUid);
+
+  // Request file icon for the newly opened tab
+  try {
+    const newTab = findTabById(readyState, tabId);
+    if (newTab && newTab.tab.uri) {
+      const {
+        newFileIconCache
+      } = await getFileIconsForTabs([newTab.tab], readyState.fileIconCache);
+      const icon = newFileIconCache[newTab.tab.uri] || '';
+
+      // Update the tab with the icon
+      const stateWithIcon = {
+        ...readyState,
+        fileIconCache: newFileIconCache,
+        layout: {
+          ...readyState.layout,
+          groups: readyState.layout.groups.map(group => ({
+            ...group,
+            tabs: group.tabs.map(tab => tab.id === tabId ? {
+              ...tab,
+              icon
+            } : tab)
+          }))
+        }
+      };
+      return stateWithIcon;
+    }
+  } catch {
+    // If icon request fails, continue without icon
+  }
   return readyState;
 };
 
@@ -2406,6 +2697,13 @@ const refresh = state => {
   };
 };
 
+const Button = 1;
+const Div = 4;
+const Span = 8;
+const Text = 12;
+const Img = 17;
+const Pre = 51;
+
 const text = data => {
   return {
     childCount: 0,
@@ -2417,17 +2715,18 @@ const text = data => {
 const CSS_CLASSES = {
   EDITOR_GROUPS_CONTAINER: 'editor-groups-container'};
 
-const renderLoading = () => {
+const renderContent = content => {
   return [{
     childCount: 1,
-    className: 'TextEditor TextEditor--loading',
+    className: 'TextEditor',
     type: Div
   }, {
     childCount: 1,
-    className: 'EditorContent EditorContent--loading',
-    type: Div
-  }, text('Loading...')];
+    className: 'EditorContent',
+    type: Pre
+  }, text(content)];
 };
+
 const renderError = errorMessage => {
   return [{
     childCount: 1,
@@ -2439,17 +2738,19 @@ const renderError = errorMessage => {
     type: Div
   }, text(`Error: ${errorMessage}`)];
 };
-const renderContent = content => {
+
+const renderLoading = () => {
   return [{
     childCount: 1,
-    className: 'TextEditor',
+    className: 'TextEditor TextEditor--loading',
     type: Div
   }, {
     childCount: 1,
-    className: 'EditorContent',
-    type: Pre
-  }, text(content)];
+    className: 'EditorContent EditorContent--loading',
+    type: Div
+  }, text('Loading...')];
 };
+
 const renderViewletReference = tab => {
   return [{
     childCount: 0,
@@ -2458,6 +2759,7 @@ const renderViewletReference = tab => {
     uid: tab.editorUid
   }];
 };
+
 const renderEditor = tab => {
   if (!tab) {
     // Keep backward compatible behavior: render empty content
@@ -2504,7 +2806,7 @@ const renderTab = (tab, isActive, tabIndex, groupIndex) => {
   }, {
     childCount: 0,
     className: 'TabIcon',
-    src: 'icons/refresh.svg',
+    src: tab.icon,
     type: Img
   }, {
     childCount: 1,
@@ -2516,7 +2818,7 @@ const renderTab = (tab, isActive, tabIndex, groupIndex) => {
     'data-groupIndex': groupIndex,
     'data-index': tabIndex,
     onClick: HandleClickClose,
-    type: Button$1
+    type: Button
   }, text('×')];
 };
 
@@ -2588,7 +2890,7 @@ const render2 = (uid, diffResult) => {
     newState,
     oldState
   } = get$2(uid);
-  set$3(uid, newState, newState);
+  set$4(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
@@ -2605,7 +2907,7 @@ const renderEventListeners = () => {
     params: ['handleClickTab', 'event.target.dataset.groupIndex', 'event.target.dataset.index']
   }, {
     name: HandleTabContextMenu,
-    params: ['handleTabContextMenu', Button, ClientX, ClientY],
+    params: ['handleTabContextMenu', Button$1, ClientX, ClientY],
     preventDefault: true
   }];
 };
@@ -2649,6 +2951,26 @@ const commandMap = {
   'MainArea.terminate': terminate
 };
 
+const send = port => {
+  return sendMessagePortToIconThemeWorker(port, 0);
+};
+const createIconThemeWorkerRpc = async () => {
+  try {
+    const rpc = await LazyTransferMessagePortRpcParent.create({
+      commandMap: {},
+      send
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create icon theme worker rpc`);
+  }
+};
+
+const initializeIconThemeWorker = async () => {
+  const rpc = await createIconThemeWorkerRpc();
+  set$1(rpc);
+};
+
 const initializeRendererWorker = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
@@ -2658,7 +2980,7 @@ const initializeRendererWorker = async () => {
 
 const listen = async () => {
   registerCommands(commandMap);
-  await initializeRendererWorker();
+  await Promise.all([initializeRendererWorker(), initializeIconThemeWorker()]);
 };
 
 const main$2 = async () => {

package/package.json

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