@electerm/electerm-react 1.51.1 → 1.51.8

package/client/store/tab.js

@@ -2,16 +2,19 @@
  * tabs related functions
  */
 
-import { debounce } from 'lodash-es'
+import { debounce, isEqual } from 'lodash-es'
 import {
   splitConfig,
   statusMap,
-  paneMap
+  paneMap,
+  maxHistory
 } from '../common/constants'
 import * as ls from '../common/safe-local-storage'
 import deepCopy from 'json-deep-copy'
 import generate from '../common/id-with-stamp'
+import uid from '../common/uid'
 import newTerm from '../common/new-terminal.js'
+import { action } from 'manate'
 
 export default Store => {
   Store.prototype.getTabs = function () {
@@ -60,10 +63,10 @@ export default Store => {
       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
+        if (closingTab.id === store.activeTabId) {
+          store.activeTabId = id
+        } else if (closingTab.id === store[`activeTabId${targetBatch}`]) {
+          store[`activeTabId${targetBatch}`] = id
         }
 
         tabs.splice(i, 1)
@@ -71,7 +74,7 @@ export default Store => {
     }
   }
 
-  Store.prototype.reloadTab = function (tabId = window.store.currentTabId) {
+  Store.prototype.reloadTab = function (tabId = window.store.activeTabId) {
     const { store } = window
     const { tabs } = store
     const index = tabs.findIndex(t => t.id === tabId)
@@ -82,6 +85,7 @@ export default Store => {
     }
 
     const oldTab = tabs[index]
+    const oldBatch = oldTab.batch
 
     // Create copy of old tab with new ID
     const newTab = {
@@ -92,17 +96,18 @@ export default Store => {
 
     // Add new tab at next index
     tabs.splice(index + 1, 0, newTab)
+    store.updateHistory(newTab)
 
     // Remove old tab
     tabs.splice(index, 1)
 
     // Update current tab ID if needed
-    if (store.currentTabId === tabId) {
-      store.currentTabId = newTab.id
+    if (store.activeTabId === tabId) {
+      store.activeTabId = newTab.id
     }
 
     // Update batch current tab ID if needed
-    const batchProp = `currentTabId${oldTab.batch}`
+    const batchProp = `activeTabId${oldBatch}`
     if (store[batchProp] === tabId) {
       store[batchProp] = newTab.id
     }
@@ -128,10 +133,11 @@ export default Store => {
 
     // Insert the duplicated tab after the source tab
     tabs.splice(targetIndex + 1, 0, duplicatedTab)
+    store.updateHistory(duplicatedTab)
 
     // Set the duplicated tab as current
-    store.currentTabId = duplicatedTab.id
-    store[`currentTabId${sourceTab.batch}`] = duplicatedTab.id
+    store.activeTabId = duplicatedTab.id
+    store[`activeTabId${sourceTab.batch}`] = duplicatedTab.id
   }
 
   Store.prototype.closeOtherTabs = function (id) {
@@ -146,11 +152,11 @@ export default Store => {
     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.activeTabId) {
+          store.activeTabId = id
         }
-        if (tab.id === store[`currentTabId${currentBatch}`]) {
-          store[`currentTabId${currentBatch}`] = id
+        if (tab.id === store[`activeTabId${currentBatch}`]) {
+          store[`activeTabId${currentBatch}`] = id
         }
         tabs.splice(i, 1)
       }
@@ -208,7 +214,7 @@ export default Store => {
     const store = window.store
     const removedSet = new Set(removedIds)
     const batchFirstTabs = {}
-    const currentIdNeedFix = removedSet.has(store.currentTabId)
+    const currentIdNeedFix = removedSet.has(store.activeTabId)
 
     // Get first valid tab for each batch
     for (const tab of remainingTabs) {
@@ -220,23 +226,23 @@ export default Store => {
     // 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 currentTab = remainingTabs.find(t => t.id === store.activeTabId)
       const currentBatch = currentTab ? currentTab.batch : store.currentLayoutBatch
       const newCurrentId = batchFirstTabs[currentBatch] || batchFirstTabs[0] || ''
 
       if (newCurrentId) {
-        store.currentTabId = newCurrentId
+        store.activeTabId = newCurrentId
         // Also update the batch-specific current tab id
-        store[`currentTabId${currentBatch}`] = newCurrentId
+        store[`activeTabId${currentBatch}`] = newCurrentId
       } else {
         // No tabs left in any batch
-        store.currentTabId = ''
+        store.activeTabId = ''
       }
     }
 
     // Fix batch-specific current tab IDs
     for (const batch in batchFirstTabs) {
-      const batchTabId = `currentTabId${batch}`
+      const batchTabId = `activeTabId${batch}`
       const currentBatchId = store[batchTabId]
 
       // If the batch's current tab was removed or doesn't exist
@@ -284,10 +290,10 @@ export default Store => {
     store.currentLayoutBatch = batch
 
     // Update current tab id
-    store.currentTabId = id
+    store.activeTabId = id
 
     // Update batch-specific current tab id
-    store[`currentTabId${batch}`] = id
+    store[`activeTabId${batch}`] = id
   }
 
   Store.prototype.addTab = function (
@@ -304,9 +310,10 @@ export default Store => {
       tabs.push(newTab)
     }
     const batchNum = newTab.batch
-    store[`currentTabId${batchNum}`] = newTab.id
-    store.currentTabId = newTab.id
+    store[`activeTabId${batchNum}`] = newTab.id
+    store.activeTabId = newTab.id
     store.currentLayoutBatch = batchNum
+    store.updateHistory(newTab)
   }
 
   Store.prototype.clickNextTab = debounce(function () {
@@ -319,10 +326,10 @@ export default Store => {
 
   Store.prototype.clickBioTab = function (diff) {
     const { store } = window
-    const { tabs, currentTabId } = store
+    const { tabs, activeTabId } = store
 
     // Find the current tab index and its batch
-    const currentIndex = tabs.findIndex(t => t.id === currentTabId)
+    const currentIndex = tabs.findIndex(t => t.id === activeTabId)
     if (currentIndex === -1) return // Current tab not found, do nothing
 
     const currentBatch = tabs[currentIndex].batch
@@ -342,9 +349,9 @@ export default Store => {
     // Find the next tab index
     const nextIndex = findNextTabIndex(currentIndex, diff)
 
-    // If a valid next tab is found, update the currentTabId
+    // If a valid next tab is found, update the activeTabId
     if (nextIndex !== -1 && nextIndex !== currentIndex) {
-      store.currentTabId = tabs[nextIndex].id
+      store.activeTabId = tabs[nextIndex].id
     }
   }
 
@@ -376,11 +383,11 @@ export default Store => {
   Store.prototype.setLayout = function (layout) {
     const { store } = window
     const prevLayout = store.layout
-    const { currentTabId } = store
+    const { activeTabId } = store
 
     // If layout hasn't changed, do nothing
     if (prevLayout === layout) {
-      return
+      return store.focus()
     }
 
     // Update layout related properties
@@ -400,8 +407,8 @@ export default Store => {
         const tab = store.tabs[i]
         if (tab.batch >= newBatchCount) {
           store.tabs[i].batch = nb
-          if (tab.id === currentTabId) {
-            store[`currentTabId${nb}`] = currentTabId
+          if (tab.id === activeTabId) {
+            store[`activeTabId${nb}`] = activeTabId
           }
         }
       }
@@ -413,4 +420,65 @@ export default Store => {
     }
     store.focus()
   }
+
+  Store.prototype.changeActiveTabId = function (id) {
+    const { store } = window
+    const { tabs } = store
+    const tab = tabs.find(t => t.id === id)
+    if (!tab) {
+      return
+    }
+    store.activeTabId = id
+    store[`activeTabId${tab.batch}`] = id
+    store.focus()
+  }
+
+  Store.prototype.updateHistory = function (tab) {
+    if (!tab.type && !tab.host) {
+      return
+    }
+    const { store } = window
+    const tabPropertiesExcludes = [
+      'id',
+      'from',
+      'srcId',
+      'status',
+      'pane',
+      'batch'
+    ]
+    const { history } = store
+    const index = history.findIndex(d => {
+      for (const key in tab) {
+        if (tabPropertiesExcludes.includes(key)) {
+          continue
+        }
+        if (!isEqual(d.tab[key], tab[key])) {
+          return false
+        }
+      }
+      return true
+    })
+    if (index === -1) {
+      const copiedTab = deepCopy(tab)
+      tabPropertiesExcludes.forEach(d => {
+        delete copiedTab[d]
+      })
+      return history.unshift({
+        tab: copiedTab,
+        time: Date.now(),
+        count: 1,
+        id: uid()
+      })
+    }
+    const match = history[index]
+    match.count = (match.count || 0) + 1
+    match.time = Date.now()
+    action(function () {
+      const [m] = history.splice(index, 1)
+      history.unshift(m)
+      if (history.length > maxHistory) {
+        history.pop()
+      }
+    })()
+  }
 }

package/client/store/transfer-history.js

@@ -4,20 +4,14 @@
 
 export default Store => {
   Store.prototype.clearTransferHistory = function () {
-    window.store.setItems('transferHistory', [])
+    window.store.transferHistory = []
   }
 
   Store.prototype.getTransferHistory = function () {
-    return window.store.getItems('transferHistory')
+    return window.store.transferHistory
   }
 
   Store.prototype.addTransferHistory = function (item) {
-    const { store } = window
-    const transferHistory = store.getItems('transferHistory')
-    transferHistory.unshift(item)
-    store.setItems(
-      'transferHistory',
-      transferHistory
-    )
+    window.store.transferHistory.unshift(item)
   }
 }

package/client/store/transfer-list.js

@@ -1,103 +1,103 @@
-import { findIndex } from 'lodash-es'
+/**
+ * file transfer list related functions
+ */
+const { assign } = Object
+
 export default Store => {
   Store.prototype.handleTransferTab = function (tab) {
     window.store.transferTab = tab
   }
 
-  Store.prototype.setTransfers = function (list, _sessId) {
-    const { store } = window
-    let oldList = store.fileTransfers
-    const sessId = _sessId || list[0].sessionId
-    const arr2 = oldList.filter(t => {
-      return t.sessionId === sessId
-    })
-    const idsToRm = arr2.reduce((prev, curr) => {
-      if (!list.find(l => l.id === curr.id)) {
-        prev.push(curr.id)
-      }
-      return prev
-    }, [])
-    if (idsToRm.length) {
-      oldList = oldList.filter(t => {
-        return !idsToRm.includes(t.id)
-      })
-    }
-    for (const ntm of list) {
-      const index = findIndex(oldList, t => {
-        return t.id === ntm.id
-      })
-      if (index >= 0) {
-        oldList[index] = ntm
-        continue
-      } else {
-        oldList.unshift(ntm)
-      }
+  Store.prototype.updateTransfer = function (id, update) {
+    const { fileTransfers } = window.store
+    const index = fileTransfers.findIndex(t => t.id === id)
+    if (index < 0) {
+      return
     }
-    store.setItems('fileTransfers', oldList)
-  }
-  Store.prototype.getTransfers = function () {
-    return window.store.getItems('fileTransfers')
-  }
-  Store.prototype.delTransfers = function (ids) {
-    return window.store.delItems(ids, 'fileTransfers')
-  }
-  Store.prototype.editTransfer = function (id, updates) {
-    return window.store.editItem(id, updates, 'fileTransfers')
-  }
-  Store.prototype.addTransfers = function (objs) {
-    return window.store.addItems(objs, 'fileTransfers')
+    assign(fileTransfers[index], update)
   }
-  Store.prototype.setFileTransfers = function (objs) {
-    return window.store.setState('fileTransfers', objs.filter(d => !d.cancel))
-  }
-  Store.prototype.addTransferList = function (objs) {
-    const { store } = window
-    store.setFileTransfers([
-      ...store.fileTransfers,
-      ...objs
-    ])
+
+  Store.prototype.addTransferList = function (items) {
+    const { fileTransfers } = window.store
+    fileTransfers.push(...items)
   }
+
   Store.prototype.toggleTransfer = function (itemId) {
-    const { store } = window
-    const { fileTransfers } = store
-    const index = findIndex(fileTransfers, t => t.id === itemId)
+    const { fileTransfers } = window.store
+    const index = fileTransfers.findIndex(t => t.id === itemId)
     if (index < 0) {
       return
     }
     fileTransfers[index].pausing = !fileTransfers[index].pausing
-    store.setFileTransfers(fileTransfers)
   }
 
   Store.prototype.pauseAll = function () {
-    const { store } = window
-    store.pauseAllTransfer = true
-    store.setFileTransfers(store.fileTransfers.map(t => {
-      t.pausing = true
-      return t
-    }))
+    const { fileTransfers } = window.store
+    window.store.pauseAllTransfer = true
+    const len = fileTransfers.length
+    for (let i = 0; i < len; i++) {
+      fileTransfers[i].pausing = true
+    }
   }
+
   Store.prototype.resumeAll = function () {
-    const { store } = window
-    store.pauseAllTransfer = false
-    store.setFileTransfers(store.fileTransfers.map(t => {
-      t.pausing = false
-      return t
-    }))
+    const { fileTransfers } = window.store
+    window.store.pauseAllTransfer = false
+    const len = fileTransfers.length
+    for (let i = 0; i < len; i++) {
+      fileTransfers[i].pausing = false
+    }
   }
+
   Store.prototype.cancelAll = function () {
-    const arr = document.querySelectorAll('.sftp-transport .transfer-control-cancel')
-    arr.forEach(d => {
-      d.click()
-    })
+    const { fileTransfers } = window.store
+    const len = fileTransfers.length
+    for (let i = len - 1; i >= 0; i--) {
+      fileTransfers[i].cancel = true
+      fileTransfers.splice(i, 1)
+    }
   }
+
   Store.prototype.cancelTransfer = function (itemId) {
-    const { store } = window
-    const { fileTransfers } = store
-    const index = findIndex(fileTransfers, t => t.id === itemId)
+    const { fileTransfers } = window.store
+    const index = fileTransfers.findIndex(t => t.id === itemId)
     if (index < 0) {
       return
     }
     fileTransfers[index].cancel = true
-    store.setFileTransfers(fileTransfers)
+    fileTransfers.splice(index, 1)
+  }
+
+  Store.prototype.removeTransfer = function (id) {
+    const { fileTransfers } = window.store
+    const index = fileTransfers.findIndex(t => t.id === id)
+    if (index > -1) {
+      fileTransfers.splice(index, 1)
+    }
+  }
+
+  Store.prototype.skipAllTransfersSinceIndex = function (index) {
+    window.store.fileTransfers.splice(index)
+  }
+
+  Store.prototype.updateTransfersFromIndex = function (index, update) {
+    const { fileTransfers } = window.store
+    if (index < 0 || index >= fileTransfers.length) {
+      return
+    }
+    const len = fileTransfers.length
+    for (let i = index; i < len; i++) {
+      assign(fileTransfers[i], update)
+    }
+  }
+
+  // Add a new method to find index by ID and then update
+  Store.prototype.updateTransfersFromId = function (id, update) {
+    const { fileTransfers } = window.store
+    const index = fileTransfers.findIndex(t => t.id === id)
+    if (index < 0) {
+      return
+    }
+    window.store.updateTransfersFromIndex(index, update)
   }
 }

package/client/store/watch.js

@@ -20,7 +20,7 @@ export default store => {
   //   store.focus()
   //   // store.termSearchOpen = false
   //   store.termSearchMatchCount = 0
-  //   return store.currentTabId
+  //   return store.activeTabId
   // }).start()
 
   // autoRun(() => {
@@ -43,7 +43,7 @@ export default store => {
         await store.uploadSettingAll()
       }
       return store['_' + name]
-    }, func => debounce(func, 100)).start()
+    }).start()
   }
 
   autoRun(async () => {
@@ -97,15 +97,23 @@ export default store => {
     return store._checkedKeys
   }).start()
 
+  autoRun(() => {
+    ls.setItemJSON('history', store.history)
+    return store.history
+  }).start()
+
   autoRun(() => {
     const tabs = store.getTabs()
-    const { currentTabId } = store
-    const tab = tabs.find(t => t.id === currentTabId)
+    const { activeTabId } = store
+    const tab = tabs.find(t => t.id === activeTabId)
     if (tab) {
       const title = createTitle(tab)
       window.pre.runGlobalAsync('setTitle', title)
       window.store.currentLayoutBatch = tab.batch
     }
-    return store.currentTabId
+    if (tab && store.rightPanelVisible) {
+      window.store.openInfoPanel()
+    }
+    return store.activeTabId
   }).start()
 }

package/package.json

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

package/client/components/setting-panel/tab-history.jsx

@@ -1,43 +0,0 @@
-import SettingCol from './col'
-import BookmarkForm from '../bookmark-form'
-import List from './list'
-import {
-  settingMap
-} from '../../common/constants'
-
-const e = window.translate
-
-export default function TabHistory (props) {
-  const {
-    settingTab
-  } = props
-  if (settingTab !== settingMap.history) {
-    return null
-  }
-  const {
-    settingItem,
-    listProps,
-    formProps
-  } = props
-  return (
-    <div
-      className='setting-tabs-history'
-    >
-      <SettingCol>
-        <List
-          {...listProps}
-        />
-        {
-          settingItem.id
-            ? (
-              <BookmarkForm
-                key={settingItem.id}
-                {...formProps}
-              />
-              )
-            : <div className='form-wrap pd2 aligncenter'>{e('notFoundContent')}</div>
-        }
-      </SettingCol>
-    </div>
-  )
-}