@lvce-editor/main-area-worker 6.6.0 → 6.7.0

package/dist/mainAreaWorkerMain.js

@@ -1718,157 +1718,6 @@ const diff2 = uid => {
   return result;
 };
 
-const getMenuIds = () => {
-  return [Tab];
-};
-
-const handleClick = async (state, name) => {
-  if (!name) {
-    return state;
-  }
-  return state;
-};
-
-const closeEditorGroup = (state, groupId) => {
-  const {
-    layout
-  } = state;
-  const {
-    activeGroupId,
-    groups
-  } = layout;
-  const groupIndex = groups.findIndex(group => group.id === groupId);
-  if (groupIndex === -1 || groups.length <= 1) {
-    return state;
-  }
-  const remainingGroups = groups.filter(group => group.id !== groupId);
-  const baseSize = Math.floor(100 / remainingGroups.length);
-  const remainder = 100 % remainingGroups.length;
-  const redistributedGroups = remainingGroups.map((group, index) => ({
-    ...group,
-    size: baseSize + (index === remainingGroups.length - 1 ? remainder : 0)
-  }));
-  const newActiveGroupId = activeGroupId === groupId ? remainingGroups[0].id : activeGroupId;
-  return {
-    ...state,
-    layout: {
-      ...layout,
-      activeGroupId: newActiveGroupId,
-      groups: redistributedGroups
-    }
-  };
-};
-
-const getActiveGroup = (groups, activeGroupId) => {
-  return groups.find(g => g.id === activeGroupId);
-};
-
-const Left = 'left';
-const Right = 'right';
-
-const splitEditorGroup$1 = (state, groupId, direction) => {
-  const {
-    layout
-  } = state;
-  const {
-    groups
-  } = layout;
-  const sourceGroup = groups.find(group => group.id === groupId);
-  if (!sourceGroup) {
-    return state;
-  }
-  const newGroupId = create$1();
-  const isHorizontalSplit = direction === Left || direction === Right;
-  const newLayoutDirection = isHorizontalSplit ? 'horizontal' : 'vertical';
-  const updatedGroups = groups.map(group => {
-    if (group.id === groupId) {
-      return {
-        ...group,
-        focused: false,
-        size: 50
-      };
-    }
-    return group;
-  });
-  const newGroup = {
-    activeTabId: undefined,
-    focused: true,
-    id: newGroupId,
-    isEmpty: true,
-    size: 50,
-    tabs: []
-  };
-  let reorderedGroups;
-  if (direction === Right || direction === 'down') {
-    reorderedGroups = [...updatedGroups, newGroup];
-  } else {
-    const sourceIndex = updatedGroups.findIndex(group => group.id === groupId);
-    reorderedGroups = [...updatedGroups.slice(0, sourceIndex), newGroup, ...updatedGroups.slice(sourceIndex)];
-  }
-  return {
-    ...state,
-    layout: {
-      activeGroupId: newGroupId,
-      direction: newLayoutDirection,
-      groups: reorderedGroups
-    }
-  };
-};
-
-const handleClickAction = async (state, action, rawGroupId) => {
-  if (!action) {
-    return state;
-  }
-  if (state.layout.activeGroupId === undefined) {
-    return state;
-  }
-  const activeGroup = getActiveGroup(state.layout.groups, state.layout.activeGroupId);
-  if (!activeGroup) {
-    return state;
-  }
-  switch (action) {
-    case 'close-group':
-      if (rawGroupId) {
-        const groupId = Number.parseInt(rawGroupId, 10);
-        if (!Number.isNaN(groupId)) {
-          return closeEditorGroup(state, groupId);
-        }
-      }
-      return state;
-    case 'split-right':
-      return splitEditorGroup$1(state, activeGroup.id, Right);
-    default:
-      return state;
-  }
-};
-
-const handleClickCloseTab = (state, rawGroupIndex, rawIndex) => {
-  if (!rawGroupIndex || !rawIndex) {
-    return state;
-  }
-  const groupIndex = Number.parseInt(rawGroupIndex);
-  const index = Number.parseInt(rawIndex);
-  const {
-    layout
-  } = state;
-  const {
-    groups
-  } = layout;
-
-  // Validate indexes
-  if (groupIndex < 0 || groupIndex >= groups.length) {
-    return state;
-  }
-  const group = groups[groupIndex];
-  if (index < 0 || index >= group.tabs.length) {
-    return state;
-  }
-  const tab = group.tabs[index];
-  const groupId = group.id;
-  const tabId = tab.id;
-  return closeTab(state, groupId, tabId);
-};
-
 const createViewlet = async (viewletModuleId, editorUid, tabId, bounds, uri) => {
   await invoke('Layout.createViewlet', viewletModuleId, editorUid, tabId, bounds, uri);
 };
@@ -2080,6 +1929,225 @@ const selectTab = async (state, groupIndex, index) => {
   return newState;
 };
 
+const focusNextTab = async state => {
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    groups
+  } = layout;
+
+  // Find the active group
+  const activeGroup = groups.find(g => g.id === activeGroupId);
+  if (!activeGroup || activeGroup.isEmpty) {
+    return state;
+  }
+
+  // Find the index of the active group
+  const activeGroupIndex = groups.findIndex(g => g.id === activeGroupId);
+  if (activeGroupIndex === -1) {
+    return state;
+  }
+
+  // Find the current active tab index
+  const activeTabIndex = activeGroup.tabs.findIndex(t => t.id === activeGroup.activeTabId);
+  if (activeTabIndex === -1) {
+    return state;
+  }
+
+  // If not at the last tab, select the next tab
+  if (activeTabIndex < activeGroup.tabs.length - 1) {
+    return selectTab(state, activeGroupIndex, activeTabIndex + 1);
+  }
+  return state;
+};
+
+const focusPreviousTab = async state => {
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    groups
+  } = layout;
+
+  // Find the active group
+  const activeGroup = groups.find(g => g.id === activeGroupId);
+  if (!activeGroup || activeGroup.isEmpty) {
+    return state;
+  }
+
+  // Find the index of the active group
+  const activeGroupIndex = groups.findIndex(g => g.id === activeGroupId);
+  if (activeGroupIndex === -1) {
+    return state;
+  }
+
+  // Find the current active tab index
+  const activeTabIndex = activeGroup.tabs.findIndex(t => t.id === activeGroup.activeTabId);
+  if (activeTabIndex === -1) {
+    return state;
+  }
+
+  // If not at the first tab, select the previous tab
+  if (activeTabIndex > 0) {
+    return selectTab(state, activeGroupIndex, activeTabIndex - 1);
+  }
+  return state;
+};
+
+const getMenuIds = () => {
+  return [Tab];
+};
+
+const handleClick = async (state, name) => {
+  if (!name) {
+    return state;
+  }
+  return state;
+};
+
+const closeEditorGroup = (state, groupId) => {
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    groups
+  } = layout;
+  const groupIndex = groups.findIndex(group => group.id === groupId);
+  if (groupIndex === -1 || groups.length <= 1) {
+    return state;
+  }
+  const remainingGroups = groups.filter(group => group.id !== groupId);
+  const baseSize = Math.floor(100 / remainingGroups.length);
+  const remainder = 100 % remainingGroups.length;
+  const redistributedGroups = remainingGroups.map((group, index) => ({
+    ...group,
+    size: baseSize + (index === remainingGroups.length - 1 ? remainder : 0)
+  }));
+  const newActiveGroupId = activeGroupId === groupId ? remainingGroups[0].id : activeGroupId;
+  return {
+    ...state,
+    layout: {
+      ...layout,
+      activeGroupId: newActiveGroupId,
+      groups: redistributedGroups
+    }
+  };
+};
+
+const getActiveGroup = (groups, activeGroupId) => {
+  return groups.find(g => g.id === activeGroupId);
+};
+
+const Left = 'left';
+const Right = 'right';
+
+const splitEditorGroup$1 = (state, groupId, direction) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  const sourceGroup = groups.find(group => group.id === groupId);
+  if (!sourceGroup) {
+    return state;
+  }
+  const newGroupId = create$1();
+  const isHorizontalSplit = direction === Left || direction === Right;
+  const newLayoutDirection = isHorizontalSplit ? 'horizontal' : 'vertical';
+  const updatedGroups = groups.map(group => {
+    if (group.id === groupId) {
+      return {
+        ...group,
+        focused: false,
+        size: 50
+      };
+    }
+    return group;
+  });
+  const newGroup = {
+    activeTabId: undefined,
+    focused: true,
+    id: newGroupId,
+    isEmpty: true,
+    size: 50,
+    tabs: []
+  };
+  let reorderedGroups;
+  if (direction === Right || direction === 'down') {
+    reorderedGroups = [...updatedGroups, newGroup];
+  } else {
+    const sourceIndex = updatedGroups.findIndex(group => group.id === groupId);
+    reorderedGroups = [...updatedGroups.slice(0, sourceIndex), newGroup, ...updatedGroups.slice(sourceIndex)];
+  }
+  return {
+    ...state,
+    layout: {
+      activeGroupId: newGroupId,
+      direction: newLayoutDirection,
+      groups: reorderedGroups
+    }
+  };
+};
+
+const handleClickAction = async (state, action, rawGroupId) => {
+  if (!action) {
+    return state;
+  }
+  if (state.layout.activeGroupId === undefined) {
+    return state;
+  }
+  const activeGroup = getActiveGroup(state.layout.groups, state.layout.activeGroupId);
+  if (!activeGroup) {
+    return state;
+  }
+  switch (action) {
+    case 'close-group':
+      if (rawGroupId) {
+        const groupId = Number.parseInt(rawGroupId, 10);
+        if (!Number.isNaN(groupId)) {
+          return closeEditorGroup(state, groupId);
+        }
+      }
+      return state;
+    case 'split-right':
+      return splitEditorGroup$1(state, activeGroup.id, Right);
+    default:
+      return state;
+  }
+};
+
+const handleClickCloseTab = (state, rawGroupIndex, rawIndex) => {
+  if (!rawGroupIndex || !rawIndex) {
+    return state;
+  }
+  const groupIndex = Number.parseInt(rawGroupIndex);
+  const index = Number.parseInt(rawIndex);
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+
+  // Validate indexes
+  if (groupIndex < 0 || groupIndex >= groups.length) {
+    return state;
+  }
+  const group = groups[groupIndex];
+  if (index < 0 || index >= group.tabs.length) {
+    return state;
+  }
+  const tab = group.tabs[index];
+  const groupId = group.id;
+  const tabId = tab.id;
+  return closeTab(state, groupId, tabId);
+};
+
 const handleClickTab = async (state, groupIndexRaw, indexRaw) => {
   if (!groupIndexRaw || !indexRaw) {
     return state;
@@ -2094,6 +2162,36 @@ const handleDoubleClick = async state => {
   return state;
 };
 
+const handleModifiedStatusChange = (state, uri, newStatus) => {
+  const {
+    layout
+  } = state;
+  const {
+    groups
+  } = layout;
+  const updatedGroups = groups.map(group => {
+    return {
+      ...group,
+      tabs: group.tabs.map(tab => {
+        if (tab.uri === uri) {
+          return {
+            ...tab,
+            isDirty: newStatus
+          };
+        }
+        return tab;
+      })
+    };
+  });
+  return {
+    ...state,
+    layout: {
+      ...layout,
+      groups: updatedGroups
+    }
+  };
+};
+
 const handleResize = async (state, x, y, width, height) => {
   number(x);
   number(y);
@@ -2976,7 +3074,7 @@ const openUri = async (state, options) => {
   } = state;
   const uri = getOptionUriOptions(options);
 
-  // Check if a tab with this URI already exists
+  // Check if a tab with this URI already exists in the passed-in state
   const existingTab = findTabByUri(state, uri);
   if (existingTab) {
     // Tab exists, switch to it and focus its group
@@ -2986,22 +3084,56 @@ const openUri = async (state, options) => {
 
   // Get previous active tab ID for viewlet switching
   getActiveTabId(state);
-  const newState = ensureActiveGroup(state, uri);
+
+  // Check if there's existing state in the global store
+  const stateFromStore = get(uid);
+  let currentState;
+  if (stateFromStore) {
+    const storedState = stateFromStore.newState;
+    // Use the stored state if it has more tabs than the passed-in state
+    // (indicating concurrent calls have already added tabs)
+    // Otherwise use the passed-in state (test setup with initial data)
+    const storedTabCount = storedState.layout.groups.reduce((sum, g) => sum + g.tabs.length, 0);
+    const passedTabCount = state.layout.groups.reduce((sum, g) => sum + g.tabs.length, 0);
+    if (storedTabCount > passedTabCount) {
+      // Stored state has more tabs - concurrent calls have added tabs
+      currentState = storedState;
+    } else {
+      // Passed-in state has same or more tabs, use it (likely fresh test setup)
+      currentState = state;
+      set(uid, state, state);
+    }
+  } else {
+    // No state in store yet, register the passed-in state
+    currentState = state;
+    set(uid, state, state);
+  }
+
+  // Add tab to state BEFORE any async calls to prevent race conditions
+  const newState = ensureActiveGroup(currentState, uri);
   const tabId = getActiveTabId(newState);
+
+  // Save state immediately after adding tab
+  set(uid, currentState, newState);
   const viewletModuleId = await getViewletModuleId(uri);
+
+  // After async call, get the latest state to account for any concurrent changes
+  const {
+    newState: stateAfterModuleId
+  } = get(uid);
   if (!viewletModuleId) {
     // TODO display some kind of errro that editor couldn't be opened
-    return newState;
+    return stateAfterModuleId;
   }
 
   // Calculate bounds: use main area bounds minus tab height
   const bounds = {
-    height: newState.height - newState.tabHeight,
-    width: newState.width,
-    x: newState.x,
-    y: newState.y + newState.tabHeight
+    height: stateAfterModuleId.height - stateAfterModuleId.tabHeight,
+    width: stateAfterModuleId.width,
+    x: stateAfterModuleId.x,
+    y: stateAfterModuleId.y + stateAfterModuleId.tabHeight
   };
-  const stateWithViewlet = createViewletForTab(newState, tabId);
+  const stateWithViewlet = createViewletForTab(stateAfterModuleId, tabId);
   let intermediateState1 = stateWithViewlet;
 
   // Switch viewlet (detach old, attach new if ready)
@@ -3009,7 +3141,7 @@ const openUri = async (state, options) => {
     newState: switchedState
   } = switchViewlet(intermediateState1);
   intermediateState1 = switchedState;
-  set(uid, state, intermediateState1);
+  set(uid, stateWithViewlet, intermediateState1);
 
   // Get the tab to extract editorUid
   const tabWithViewlet = findTabById(intermediateState1, tabId);
@@ -3033,6 +3165,9 @@ const openUri = async (state, options) => {
   // Attachment is handled automatically by virtual DOM reference nodes
   const readyState = handleViewletReady(latestState, editorUid);
 
+  // Save state before async icon request
+  set(uid, intermediateState1, readyState);
+
   // Request file icon for the newly opened tab
   try {
     const newTab = findTabById(readyState, tabId);
@@ -3040,15 +3175,20 @@ const openUri = async (state, options) => {
       const {
         newFileIconCache
       } = await getFileIconsForTabs([newTab.tab], readyState.fileIconCache);
+
+      // After async call, get the latest state again
+      const {
+        newState: stateBeforeIconUpdate
+      } = get(uid);
       const icon = newFileIconCache[newTab.tab.uri] || '';
 
-      // Update the tab with the icon
+      // Update the tab with the icon in the latest state
       const stateWithIcon = {
-        ...readyState,
+        ...stateBeforeIconUpdate,
         fileIconCache: newFileIconCache,
         layout: {
-          ...readyState.layout,
-          groups: readyState.layout.groups.map(group => ({
+          ...stateBeforeIconUpdate.layout,
+          groups: stateBeforeIconUpdate.layout.groups.map(group => ({
             ...group,
             tabs: group.tabs.map(tab => tab.id === tabId ? {
               ...tab,
@@ -3057,12 +3197,20 @@ const openUri = async (state, options) => {
           }))
         }
       };
+
+      // Save the state with icon update so concurrent calls can see it
+      set(uid, stateBeforeIconUpdate, stateWithIcon);
       return stateWithIcon;
     }
   } catch {
     // If icon request fails, continue without icon
   }
-  return readyState;
+
+  // Get final latest state
+  const {
+    newState: finalState
+  } = get(uid);
+  return finalState;
 };
 
 const refresh = state => {
@@ -3437,11 +3585,48 @@ const HandleClickClose = 12;
 const HandleClickTab = 13;
 const HandleTabContextMenu = 14;
 
+const renderTabActions = (isDirty, tabIndex, groupIndex) => {
+  if (isDirty) {
+    return [{
+      childCount: 1,
+      className: 'EditorTabCloseButton',
+      'data-groupIndex': groupIndex,
+      'data-index': tabIndex,
+      type: Div
+    }, {
+      childCount: 0,
+      className: 'MaskIcon MaskIconCircleFilled',
+      type: Div
+    }];
+  }
+  return [{
+    'aria-label': 'Close',
+    childCount: 1,
+    className: 'EditorTabCloseButton',
+    'data-groupIndex': groupIndex,
+    'data-index': tabIndex,
+    onClick: HandleClickClose,
+    type: Button$1
+  }, {
+    childCount: 0,
+    className: 'MaskIcon MaskIconClose',
+    type: Div
+  }];
+};
+
 const renderTab = (tab, isActive, tabIndex, groupIndex) => {
+  const closeButtonNodes = renderTabActions(tab.isDirty, tabIndex, groupIndex);
+  let className = 'MainTab';
+  if (isActive) {
+    className += ' MainTabSelected';
+  }
+  if (tab.isDirty) {
+    className += ' MainTabModified';
+  }
   return [{
     'aria-selected': isActive,
     childCount: 3,
-    className: isActive ? 'MainTab MainTabSelected' : 'MainTab',
+    className,
     'data-groupIndex': groupIndex,
     'data-index': tabIndex,
     onClick: HandleClickTab,
@@ -3459,19 +3644,7 @@ const renderTab = (tab, isActive, tabIndex, groupIndex) => {
     childCount: 1,
     className: 'TabTitle',
     type: Span
-  }, text(tab.isDirty ? `*${tab.title}` : tab.title), {
-    'aria-label': 'Close',
-    childCount: 1,
-    className: 'EditorTabCloseButton',
-    'data-groupIndex': groupIndex,
-    'data-index': tabIndex,
-    onClick: HandleClickClose,
-    type: Button$1
-  }, {
-    childCount: 0,
-    className: 'MaskIcon MaskIconClose',
-    type: Div
-  }];
+  }, text(tab.title), ...closeButtonNodes];
 };
 
 const getTabsVirtualDom = (group, groupIndex, tabsChildCount) => {
@@ -3767,6 +3940,8 @@ const commandMap = {
   'MainArea.closeFocusedTab': wrapCommand(closeFocusedTab),
   'MainArea.create': create,
   'MainArea.diff2': diff2,
+  'MainArea.focusNextTab': wrapCommand(focusNextTab),
+  'MainArea.focusPreviousTab': wrapCommand(focusPreviousTab),
   'MainArea.getCommandIds': getCommandIds,
   'MainArea.getMenuEntries': wrapGetter(getMenuEntries),
   'MainArea.getMenuIds': getMenuIds,
@@ -3775,6 +3950,7 @@ const commandMap = {
   'MainArea.handleClickCloseTab': wrapCommand(handleClickCloseTab),
   'MainArea.handleClickTab': wrapCommand(handleClickTab),
   'MainArea.handleDoubleClick': wrapCommand(handleDoubleClick),
+  'MainArea.handleModifiedStatusChange': wrapCommand(handleModifiedStatusChange),
   'MainArea.handleResize': wrapCommand(handleResize),
   'MainArea.handleTabContextMenu': wrapCommand(handleTabContextMenu),
   'MainArea.handleUriChange': wrapCommand(handleUriChange),

package/package.json

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