@electerm/electerm-react 1.50.66 → 1.51.0

package/client/store/tab.js

@@ -2,73 +2,311 @@
  * tabs related functions
  */
 
-import { uniq, debounce, findIndex } from 'lodash-es'
+import { debounce } from 'lodash-es'
 import {
-  tabActions,
   splitConfig,
   statusMap,
   paneMap
 } from '../common/constants'
-import postMsg from '../common/post-msg'
 import * as ls from '../common/safe-local-storage'
 import deepCopy from 'json-deep-copy'
 import generate from '../common/id-with-stamp'
+import newTerm from '../common/new-terminal.js'
 
 export default Store => {
+  Store.prototype.getTabs = function () {
+    return window.store.tabs
+  }
+
+  Store.prototype.setOffline = function () {
+    const { store } = window
+    store.tabs.forEach(tab => {
+      if (tab.host && tab.status !== statusMap.error) {
+        tab.status = statusMap.error
+      }
+    })
+  }
+
   Store.prototype.updateTabsStatus = function () {
-    const tabIds = uniq(
-      window.store.fileTransfers.map(d => d.tabId)
+    const { store } = window
+    const tabIdSet = new Set(
+      store.fileTransfers.map(d => d.tabId)
     )
-    postMsg({
-      action: tabActions.updateTabsStatus,
-      tabIds
+    store.tabs.forEach(tab => {
+      tab.isTransporting = tabIdSet.has(tab.id)
     })
   }
 
-  Store.prototype.updateStoreTabs = function (tabs0, batch0) {
-    if (!tabs0.length && batch0 !== undefined) {
-      const tabs = window.store.getTabs().filter(t => t.batch !== batch0)
-      window.store.setTabs(tabs)
-      return true
+  Store.prototype.setTabs = function (list) {
+    window.store.tabs = list
+  }
+
+  Store.prototype.delTab = function (id) {
+    return window.store.removeTabs({ id })
+  }
+
+  Store.prototype.closeTabsRight = function (id) {
+    const { store } = window
+    const { tabs } = store
+    const targetTab = tabs.find(t => t.id === id)
+    if (!targetTab) {
+      return
     }
-    if (!tabs0.length) {
-      return false
+    const targetBatch = targetTab.batch
+    const targetIndex = tabs.findIndex(t => t.id === id)
+
+    // Remove all tabs in the same batch that are to the right
+    for (let i = tabs.length - 1; i > targetIndex; i--) {
+      const closingTab = tabs[i]
+      if (closingTab.batch === targetBatch) {
+        // Handle current tab closure
+        if (closingTab.id === store.currentTabId) {
+          store.currentTabId = id
+        } else if (closingTab.id === store[`currentTabId${targetBatch}`]) {
+          store[`currentTabId${targetBatch}`] = id
+        }
+
+        tabs.splice(i, 1)
+      }
     }
-    const { batch } = tabs0[0]
-    const tabs = window.store.getTabs()
-      .filter(t => t.batch !== batch)
-      .concat(deepCopy(tabs0))
-    window.store.setTabs(tabs)
   }
 
-  Store.prototype.getTabs = function () {
-    return window.store.getItems('tabs')
+  Store.prototype.reloadTab = function (tabId = window.store.currentTabId) {
+    const { store } = window
+    const { tabs } = store
+    const index = tabs.findIndex(t => t.id === tabId)
+
+    // If tab not found, do nothing
+    if (index === -1) {
+      return
+    }
+
+    const oldTab = tabs[index]
+
+    // Create copy of old tab with new ID
+    const newTab = {
+      ...oldTab,
+      id: generate(), // Need to create new ID
+      status: statusMap.processing // Reset status
+    }
+
+    // Add new tab at next index
+    tabs.splice(index + 1, 0, newTab)
+
+    // Remove old tab
+    tabs.splice(index, 1)
+
+    // Update current tab ID if needed
+    if (store.currentTabId === tabId) {
+      store.currentTabId = newTab.id
+    }
+
+    // Update batch current tab ID if needed
+    const batchProp = `currentTabId${oldTab.batch}`
+    if (store[batchProp] === tabId) {
+      store[batchProp] = newTab.id
+    }
   }
 
-  Store.prototype.setTabs = function (list) {
-    return window.store.setItems('tabs', list)
+  Store.prototype.duplicateTab = function (tabId) {
+    const { store } = window
+    const { tabs } = store
+
+    // Find the target tab and its index
+    const targetIndex = tabs.findIndex(t => t.id === tabId)
+    if (targetIndex === -1) {
+      return
+    }
+
+    const sourceTab = tabs[targetIndex]
+    const duplicatedTab = {
+      ...deepCopy(sourceTab),
+      id: generate(),
+      status: statusMap.processing,
+      isTransporting: undefined
+    }
+
+    // Insert the duplicated tab after the source tab
+    tabs.splice(targetIndex + 1, 0, duplicatedTab)
+
+    // Set the duplicated tab as current
+    store.currentTabId = duplicatedTab.id
+    store[`currentTabId${sourceTab.batch}`] = duplicatedTab.id
   }
 
-  Store.prototype.delTab = function (id) {
-    return window.store.delItem({ id }, 'tabs')
+  Store.prototype.closeOtherTabs = function (id) {
+    const { store } = window
+    const { tabs } = store
+    const targetTab = tabs.find(t => t.id === id)
+    if (!targetTab) {
+      return
+    }
+    const currentBatch = targetTab.batch
+
+    for (let i = tabs.length - 1; i >= 0; i--) {
+      const tab = tabs[i]
+      if (tab.batch === currentBatch && tab.id !== id) {
+        if (tab.id === store.currentTabId) {
+          store.currentTabId = id
+        }
+        if (tab.id === store[`currentTabId${currentBatch}`]) {
+          store[`currentTabId${currentBatch}`] = id
+        }
+        tabs.splice(i, 1)
+      }
+    }
   }
 
-  Store.prototype.initFirstTab = function () {
-    postMsg({
-      action: tabActions.initFirstTab
-    })
+  Store.prototype.removeTabs = function (condition) {
+    const { tabs } = window.store
+    const removedIds = []
+
+    if (typeof condition === 'function') {
+      for (let i = tabs.length - 1; i >= 0; i--) {
+        const tab = tabs[i]
+        if (condition(tab, i)) {
+          removedIds.push(tab.id)
+          tabs.splice(i, 1)
+        }
+      }
+    } else {
+      const keys = Object.keys(condition)
+      if (keys.length === 1) {
+        const key = keys[0]
+        const value = condition[key]
+        for (let i = tabs.length - 1; i >= 0; i--) {
+          const tab = tabs[i]
+          if (tab[key] === value) {
+            removedIds.push(tab.id)
+            tabs.splice(i, 1)
+          }
+        }
+      } else {
+        for (let i = tabs.length - 1; i >= 0; i--) {
+          let match = true
+          const tab = tabs[i]
+          for (const key in condition) {
+            if (tab[key] !== condition[key]) {
+              match = false
+              break
+            }
+          }
+          if (match) {
+            removedIds.push(tab.id)
+            tabs.splice(i, 1)
+          }
+        }
+      }
+    }
+
+    if (removedIds.length) {
+      window.store.fixCurrentTabIds(tabs, removedIds)
+    }
+  }
+
+  Store.prototype.fixCurrentTabIds = function (remainingTabs, removedIds) {
+    const store = window.store
+    const removedSet = new Set(removedIds)
+    const batchFirstTabs = {}
+    const currentIdNeedFix = removedSet.has(store.currentTabId)
+
+    // Get first valid tab for each batch
+    for (const tab of remainingTabs) {
+      if (!batchFirstTabs[tab.batch]) {
+        batchFirstTabs[tab.batch] = tab.id
+      }
+    }
+
+    // If current tab was removed, we need to set a new one
+    if (currentIdNeedFix) {
+      // Try to find current batch's first tab
+      const currentTab = remainingTabs.find(t => t.id === store.currentTabId)
+      const currentBatch = currentTab ? currentTab.batch : store.currentLayoutBatch
+      const newCurrentId = batchFirstTabs[currentBatch] || batchFirstTabs[0] || ''
+
+      if (newCurrentId) {
+        store.currentTabId = newCurrentId
+        // Also update the batch-specific current tab id
+        store[`currentTabId${currentBatch}`] = newCurrentId
+      } else {
+        // No tabs left in any batch
+        store.currentTabId = ''
+      }
+    }
+
+    // Fix batch-specific current tab IDs
+    for (const batch in batchFirstTabs) {
+      const batchTabId = `currentTabId${batch}`
+      const currentBatchId = store[batchTabId]
+
+      // If the batch's current tab was removed or doesn't exist
+      if (removedSet.has(currentBatchId) || !currentBatchId) {
+        store[batchTabId] = batchFirstTabs[batch]
+      }
+    }
+    store.focus()
+  }
+
+  Store.prototype.initFirstTab = function (batch) {
+    const { store } = window
+    if (batch !== undefined) {
+      const newTab = newTerm()
+      newTab.batch = batch // Set batch number
+      store.addTab(newTab)
+      return
+    }
+    const { layout } = store
+    const batchCount = splitConfig[layout].children || 1
+    for (let i = 0; i < batchCount; i++) {
+      const newTab = newTerm()
+      newTab.batch = i // Set batch number
+      store.addTab(newTab)
+    }
+  }
+
+  Store.prototype.updateTab = function (id, update) {
+    const { store } = window
+    const { tabs } = store
+
+    // Find the target tab
+    const targetIndex = tabs.findIndex(t => t.id === id)
+    if (targetIndex === -1) {
+      return
+    }
+    // Directly update the tab properties
+    Object.assign(tabs[targetIndex], update)
+  }
+
+  Store.prototype.clickTab = function (id, batch) {
+    const { store } = window
+
+    // Update current batch
+    store.currentLayoutBatch = batch
+
+    // Update current tab id
+    store.currentTabId = id
+
+    // Update batch-specific current tab id
+    store[`currentTabId${batch}`] = id
   }
 
   Store.prototype.addTab = function (
-    tab,
-    index
+    newTab = newTerm(),
+    index,
+    batch
   ) {
-    postMsg({
-      action: tabActions.addTab,
-      tab,
-      batch: tab?.batch ?? window.openTabBatch ?? window.store.currentLayoutBatch,
-      index
-    })
+    const { store } = window
+    const { tabs } = store
+    newTab.batch = batch ?? newTab.batch ?? window.openTabBatch ?? window.store.currentLayoutBatch
+    if (typeof index === 'number' && index >= 0 && index <= tabs.length) {
+      tabs.splice(index, 0, newTab)
+    } else {
+      tabs.push(newTab)
+    }
+    const batchNum = newTab.batch
+    store[`currentTabId${batchNum}`] = newTab.id
+    store.currentTabId = newTab.id
+    store.currentLayoutBatch = batchNum
   }
 
   Store.prototype.clickNextTab = debounce(function () {
@@ -80,30 +318,44 @@ export default Store => {
   }, 100)
 
   Store.prototype.clickBioTab = function (diff) {
-    const tab = document.querySelector('.tabs-wrapper .tab.active')
-    if (tab) {
-      const id = tab.dataset.id
-      const { tabs } = window.store
-      const i = findIndex(tabs, t => {
-        return t.id === id
-      })
-      const len = tabs.length
-      if (i >= 0) {
-        const next = (i + diff + len) % len
-        const nextTab = tabs[next]
-        postMsg({
-          action: tabActions.changeCurrentTabId,
-          currentTabId: nextTab.id
-        })
-      }
+    const { store } = window
+    const { tabs, currentTabId } = store
+
+    // Find the current tab index and its batch
+    const currentIndex = tabs.findIndex(t => t.id === currentTabId)
+    if (currentIndex === -1) return // Current tab not found, do nothing
+
+    const currentBatch = tabs[currentIndex].batch
+
+    // Function to find the next valid tab index
+    const findNextTabIndex = (startIndex, direction) => {
+      let nextIndex = startIndex
+      do {
+        nextIndex = (nextIndex + direction + tabs.length) % tabs.length
+        if (tabs[nextIndex].batch === currentBatch) {
+          return nextIndex
+        }
+      } while (nextIndex !== startIndex)
+      return -1 // No other tabs in the same batch
+    }
+
+    // Find the next tab index
+    const nextIndex = findNextTabIndex(currentIndex, diff)
+
+    // If a valid next tab is found, update the currentTabId
+    if (nextIndex !== -1 && nextIndex !== currentIndex) {
+      store.currentTabId = tabs[nextIndex].id
     }
   }
 
-  Store.prototype.cloneToNextLayout = function () {
+  Store.prototype.cloneToNextLayout = function (tab = window.store.currentTab) {
+    if (!tab) {
+      return
+    }
     const { store } = window
     const defaultStatus = statusMap.processing
-    const { currentTab, layout, currentLayoutBatch } = store
-    const ntb = deepCopy(currentTab)
+    const { layout, currentLayoutBatch } = store
+    const ntb = deepCopy(tab)
     Object.assign(ntb, {
       id: generate(),
       status: defaultStatus,
@@ -115,50 +367,50 @@ export default Store => {
       maxBatch = 2
     }
     ntb.batch = (currentLayoutBatch + 1) % maxBatch
-    store.addTab(ntb)
     if (layout === 'c1') {
       store.setLayout('c2')
     }
+    store.addTab(ntb)
   }
 
   Store.prototype.setLayout = function (layout) {
-    const {
-      store
-    } = window
+    const { store } = window
     const prevLayout = store.layout
+    const { currentTabId } = store
+
+    // If layout hasn't changed, do nothing
     if (prevLayout === layout) {
       return
     }
+
+    // Update layout related properties
     store.prevLayout = prevLayout
     ls.setItem('layout', layout)
     store.layout = layout
-    const len = splitConfig[layout].children
-    const prevLen = prevLayout ? splitConfig[prevLayout].children : 0
-    if (len < prevLen) {
-      const {
-        tabs
-      } = store
-      // Update tabs where batch > len - 1
-      const updatedTabs = tabs.map(tab => {
-        if (tab.batch > len - 1) {
-          return { ...tab, batch: len - 1 }
+
+    // Get the number of batches in new and previous layouts
+    const newBatchCount = splitConfig[layout].children
+    const prevBatchCount = prevLayout ? splitConfig[prevLayout].children : 0
+
+    // If new layout has fewer batches, we need to adjust tabs
+    if (newBatchCount < prevBatchCount) {
+      const nb = newBatchCount - 1
+      // Directly modify tabs that exceed the new batch count
+      for (let i = 0; i < store.tabs.length; i++) {
+        const tab = store.tabs[i]
+        if (tab.batch >= newBatchCount) {
+          store.tabs[i].batch = nb
+          if (tab.id === currentTabId) {
+            store[`currentTabId${nb}`] = currentTabId
+          }
         }
-        return tab
-      })
-      // Set the updated tabs back to the store
-      store.setTabs(updatedTabs)
-      setTimeout(
-        () => {
-          postMsg({
-            action: tabActions.changeCurrentTabId,
-            currentTabId: store.currentTabId
-          })
-        },
-        1000
-      )
-      if (store.currentLayoutBatch > len - 1) {
-        store.currentLayoutBatch = len - 1
+      }
+
+      // Adjust currentLayoutBatch if needed
+      if (store.currentLayoutBatch >= newBatchCount) {
+        store.currentLayoutBatch = newBatchCount - 1
       }
     }
+    store.focus()
   }
 }

package/client/store/watch.js

@@ -6,14 +6,12 @@ import createTitle from '../common/create-title'
 import { autoRun } from 'manate'
 import { update, dbNamesForWatch } from '../common/db'
 import {
-  commonActions,
   sftpDefaultSortSettingKey,
   checkedKeysLsKey,
   expandedKeysLsKey,
   resolutionsLsKey,
   localAddrBookmarkLsKey
 } from '../common/constants'
-import postMsg from '../common/post-msg'
 import * as ls from '../common/safe-local-storage'
 import { debounce, isEmpty } from 'lodash-es'
 
@@ -106,11 +104,8 @@ export default store => {
     if (tab) {
       const title = createTitle(tab)
       window.pre.runGlobalAsync('setTitle', title)
+      window.store.currentLayoutBatch = tab.batch
     }
-    postMsg({
-      action: commonActions.changeCurrentTabId,
-      currentTabId
-    })
     return store.currentTabId
   }).start()
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@electerm/electerm-react",
-  "version": "1.50.66",
+  "version": "1.51.0",
   "description": "react components src for electerm",
   "main": "./client/components/main/main.jsx",
   "license": "MIT",