@electerm/electerm-react 1.60.18 → 1.60.32

package/client/store/bookmark-group.js

@@ -7,6 +7,7 @@ import {
   defaultBookmarkGroupId,
   settingMap
 } from '../common/constants'
+import { action } from 'manate'
 
 export default Store => {
   Store.prototype.getBookmarkGroupsTotal = function () {
@@ -44,69 +45,133 @@ export default Store => {
     }
   }
 
-  Store.prototype.delBookmarkGroup = function ({ id }) {
+  Store.prototype.delBookmarkGroup = action(function ({ id }) {
     const { store } = window
+
+    // Cannot delete default group
     if (id === defaultBookmarkGroupId) {
       return
     }
-    let bookmarkGroups = store.bookmarkGroups
-    const tobeDel = find(bookmarkGroups, bg => bg.id === id)
-    if (!tobeDel) {
+
+    const { bookmarkGroups } = store
+    const index = bookmarkGroups.findIndex(bg => bg.id === id)
+
+    // If group not found, return
+    if (index === -1) {
       return
     }
-    let groups = [tobeDel]
-    if (
-      tobeDel.level !== 2 &&
-      tobeDel.bookmarkGroupIds &&
-      tobeDel.bookmarkGroupIds.length > 0
-    ) {
-      const childs = bookmarkGroups.filter(
-        bg => tobeDel.bookmarkGroupIds.includes(bg.id)
+
+    const tobeDel = bookmarkGroups[index]
+
+    // Find parent group
+    let parentGroup = null
+    if (tobeDel.level === 2) {
+      parentGroup = bookmarkGroups.find(bg =>
+        (bg.bookmarkGroupIds || []).includes(tobeDel.id)
       )
-      groups = [
-        ...groups,
-        ...childs
+    }
+
+    // If no parent found, use default group
+    if (!parentGroup) {
+      parentGroup = bookmarkGroups.find(bg => bg.id === defaultBookmarkGroupId)
+    }
+
+    // Ensure parent group has bookmarkIds and bookmarkGroupIds arrays
+    if (!parentGroup.bookmarkIds) {
+      parentGroup.bookmarkIds = []
+    }
+    if (!parentGroup.bookmarkGroupIds) {
+      parentGroup.bookmarkGroupIds = []
+    }
+
+    // Transfer bookmarkIds to parent
+    if (tobeDel.bookmarkIds && tobeDel.bookmarkIds.length) {
+      parentGroup.bookmarkIds = [
+        ...new Set([...parentGroup.bookmarkIds, ...tobeDel.bookmarkIds])
       ]
     }
-    const groupIds = groups.map(g => g.id)
-    const updates = []
-    const defaultCatIndex = tobeDel.level !== 2
-      ? bookmarkGroups.findIndex(
-        g => g.id === defaultBookmarkGroupId
-      )
-      : bookmarkGroups.findIndex(
-        g => (g.bookmarkGroupIds || []).includes(tobeDel.id)
-      )
-    for (const g of groups) {
-      if (g.bookmarkIds.length) {
-        const def = bookmarkGroups[defaultCatIndex]
-        def.bookmarkIds = [
-          ...g.bookmarkIds,
-          ...def.bookmarkIds
-        ]
-        updates.push({
-          id: def.id,
-          db: 'bookmarkGroups',
-          upsert: false,
-          update: {
-            bookmarkIds: def.bookmarkIds
-          }
-        })
+
+    // Transfer child groups to parent
+    if (tobeDel.bookmarkGroupIds && tobeDel.bookmarkGroupIds.length) {
+      parentGroup.bookmarkGroupIds = [
+        ...new Set([...parentGroup.bookmarkGroupIds, ...tobeDel.bookmarkGroupIds])
+      ]
+    }
+
+    // Remove the group from bookmarkGroups
+    bookmarkGroups.splice(index, 1)
+
+    // Reset current group if it was deleted
+    if (id === store.currentBookmarkGroupId) {
+      store.currentBookmarkGroupId = parentGroup.id
+    }
+  })
+
+  Store.prototype.fixBookmarkGroups = function () {
+    const { store } = window
+    const { bookmarks, bookmarkGroups } = store
+
+    // Create sets for quick lookup
+    const bookmarkIds = new Set(bookmarks.map(b => b.id))
+    const groupIds = new Set(bookmarkGroups.map(g => g.id))
+
+    // Fix bookmarkGroups
+    for (const group of bookmarkGroups) {
+      // Fix bookmarkIds - remove non-existent bookmark references
+      if (group.bookmarkIds) {
+        group.bookmarkIds = group.bookmarkIds.filter(id => bookmarkIds.has(id))
+      } else {
+        group.bookmarkIds = []
+      }
+
+      // Fix bookmarkGroupIds - remove non-existent group references
+      if (group.bookmarkGroupIds) {
+        group.bookmarkGroupIds = group.bookmarkGroupIds.filter(id =>
+          groupIds.has(id) && id !== group.id // Prevent self-reference
+        )
+      } else {
+        group.bookmarkGroupIds = []
       }
     }
-    bookmarkGroups = bookmarkGroups.filter(t => {
-      return !groupIds.includes(t.id)
-    })
-    store.batchDbUpdate(updates)
-    store.batchDbDel(groupIds.map(id => {
-      return {
-        id,
-        db: 'bookmarkGroups'
+
+    // Find stray bookmarks (not belonging to any group)
+    const assignedBookmarkIds = new Set(
+      bookmarkGroups.reduce((acc, group) =>
+        [...acc, ...(group.bookmarkIds || [])],
+      [])
+    )
+    const defaultGroup = bookmarkGroups.find(g => g.id === defaultBookmarkGroupId)
+    const strayBookmarkIds = bookmarks
+      .map(b => b.id)
+      .filter(id => !assignedBookmarkIds.has(id))
+
+    // Add stray bookmarks to default group
+    if (strayBookmarkIds.length) {
+      if (defaultGroup) {
+        defaultGroup.bookmarkIds = [
+          ...new Set([...defaultGroup.bookmarkIds, ...strayBookmarkIds])
+        ]
       }
-    }))
-    store.setBookmarkGroups(bookmarkGroups)
-    if (id === store.currentBookmarkGroupId) {
-      store.currentBookmarkGroupId = ''
+    }
+
+    // Find stray groups (not belonging to any parent group and not being a top-level group)
+    const assignedGroupIds = new Set(
+      bookmarkGroups.reduce((acc, group) =>
+        [...acc, ...(group.bookmarkGroupIds || [])],
+      [])
+    )
+
+    const strayGroups = bookmarkGroups.filter(group =>
+      group.level === 2 && // Only check non-top-level groups
+      group.id !== defaultBookmarkGroupId && // Exclude default group
+      !assignedGroupIds.has(group.id) // Not assigned to any parent
+    )
+
+    // Find a suitable parent for stray groups
+    if (strayGroups.length) {
+      defaultGroup.bookmarkGroupIds = [
+        ...new Set([...defaultGroup.bookmarkGroupIds, ...strayGroups.map(g => g.id)])
+      ]
     }
   }
 }

package/client/store/common.js

@@ -4,18 +4,16 @@
 
 import handleError from '../common/error-handler'
 import { Modal } from 'antd'
-import { debounce, some } from 'lodash-es'
-import postMessage from '../common/post-msg'
+import { debounce, some, get } from 'lodash-es'
 import {
-  commonActions,
   modals,
   leftSidebarWidthKey,
   rightSidebarWidthKey,
   dismissDelKeyTipLsKey,
-  connectionMap,
-  terminalActions
+  connectionMap
 } from '../common/constants'
 import * as ls from '../common/safe-local-storage'
+import { refs, refsStatic } from '../components/common/ref'
 import { action } from 'manate'
 
 const e = window.translate
@@ -34,21 +32,6 @@ export default Store => {
     window.store.setConfig(ext)
   }
 
-  Store.prototype.openFileInfoModal = function (data) {
-    postMessage({
-      data,
-      action: commonActions.showFileInfoModal
-    })
-  }
-
-  Store.prototype.openFileModeModal = function (data, file) {
-    postMessage({
-      data,
-      file,
-      action: commonActions.showFileModeModal
-    })
-  }
-
   Store.prototype.openInfoPanel = action(function () {
     const { store } = window
     store.rightPanelVisible = true
@@ -56,13 +39,13 @@ export default Store => {
     store.openInfoPanelAction()
   })
 
-  Store.prototype.openInfoPanelAction = action(function () {
+  Store.prototype.openInfoPanelAction = function () {
     const { store } = window
-    postMessage({
-      action: terminalActions.showInfoPanel,
-      activeTabId: store.activeTabId
-    })
-  })
+    setTimeout(() => {
+      const term = refs.get('term-' + store.activeTabId)
+      term && term.handleShowInfo()
+    }, 300)
+  }
 
   Store.prototype.toggleAIConfig = function () {
     window.store.showAIConfig = !window.store.showAIConfig
@@ -108,35 +91,15 @@ export default Store => {
     window.store.showModal = modals.batchOps
     async function updateText () {
       const text = await window.fs.readFile(path)
-      postMessage({
-        action: commonActions.batchOp,
-        batchOp: {
-          func: 'setState',
-          args: [
-            {
-              text
-            }
-          ]
-        }
+      refsStatic.get('batch-op')?.setState({
+        text
       })
     }
     function queue () {
-      postMessage({
-        action: commonActions.batchOp,
-        batchOp: {
-          func: 'handleClick',
-          args: []
-        }
-      })
+      refsStatic.get('batch-op')?.handleClick()
     }
     function run () {
-      postMessage({
-        action: commonActions.batchOp,
-        batchOp: {
-          func: 'handleExec',
-          args: []
-        }
-      })
+      refsStatic.get('batch-op')?.handleExec()
     }
     try {
       setTimeout(updateText, 2000)
@@ -281,11 +244,20 @@ export default Store => {
     store.rightPanelTab = 'ai'
   }
 
+  Store.prototype.explainWithAi = function (txt) {
+    const { store } = window
+    store.handleOpenAIPanel()
+    setTimeout(() => {
+      refsStatic.get('AIChat')?.setPrompt(`explain terminal output: ${txt}`)
+    }, 500)
+    setTimeout(() => {
+      refsStatic.get('AIChat')?.handleSubmit()
+    }, 1200)
+  }
+
   Store.prototype.runCommandInTerminal = function (cmd) {
-    postMessage({
-      action: terminalActions.quickCommand,
-      cmd,
-      selectedTabIds: window.store.batchInputSelectedTabIds
+    window.store.batchInputSelectedTabIds.forEach(id => {
+      refs.get('term-' + id)?.runQuickCommand(cmd)
     })
   }
 
@@ -297,4 +269,14 @@ export default Store => {
     }
     window.store.aiChatHistory.splice(index, 1)
   }
+
+  Store.prototype.getLangName = function (
+    lang = window.store?.config.language || 'en_us'
+  ) {
+    return get(window.langMap, `[${lang}].name`)
+  }
+
+  Store.prototype.getLangNames = function () {
+    return window.et.langs.map(d => d.name)
+  }
 }

package/client/store/event.js

@@ -2,48 +2,18 @@
  * extend store
  */
 
-import postMessage from '../common/post-msg'
-import { commonActions } from '../common/constants'
+import { refs } from '../components/common/ref'
 
 export default Store => {
-  Store.prototype.initStoreEvents = function () {
-    window.addEventListener('message', window.store.onStoreEvent)
-  }
-
-  Store.prototype.onStoreEvent = function (e) {
-    const { store } = window
-    const {
-      action
-    } = e.data || {}
-    if (action !== commonActions.updateStore) {
-      return false
-    }
-    const {
-      func,
-      prop,
-      value,
-      args = []
-    } = e.data || {}
-    if (func) {
-      store[func](...args)
-    } else if (prop) {
-      store[prop] = value
-    }
-  }
-
   Store.prototype.focus = function () {
     window.focused = true
-    postMessage({
-      type: 'focus'
-    })
+    refs.get('term-' + window.store.activeTabId)?.term?.focus()
   }
 
   Store.prototype.blur = function () {
     window.focused = false
     window.pre.runSync('windowMove', false)
-    postMessage({
-      type: 'blur'
-    })
+    refs.get('term-' + window.store.activeTabId)?.term?.blur()
   }
 
   Store.prototype.onBlur = function () {
@@ -55,10 +25,7 @@ export default Store => {
     document.activeElement &&
     document.activeElement.select &&
     document.activeElement.select()
-    postMessage({
-      event: 'selectall',
-      id: window.store.activeTabId
-    })
+    refs.get('term-' + window.store.activeTabId)?.term?.selectAll()
   }
 
   Store.prototype.triggerResize = function () {

package/client/store/init-state.js

@@ -51,16 +51,14 @@ export default () => {
     activeTabId: '',
     history: ls.getItemJSON('history', []),
     sshConfigs: [],
-    _bookmarks: '[]',
+    bookmarks: [],
     sidebarPanelTab: 'bookmarks',
-    _profiles: '[]',
-    _bookmarkGroups: JSON.stringify(
-      getDefaultBookmarkGroups([])
-    ),
+    profiles: [],
+    bookmarkGroups: getDefaultBookmarkGroups([]),
     _config: {},
-    _terminalThemes: JSON.stringify([
+    terminalThemes: [
       buildDefaultThemes()
-    ]),
+    ],
     itermThemes: exclude([]),
     currentBookmarkGroupId: defaultBookmarkGroupId,
     expandedKeys: ls.getItemJSON(expandedKeysLsKey, [
@@ -68,8 +66,8 @@ export default () => {
     ]),
     bookmarkSelectMode: false,
     checkedKeys: ls.getItemJSON(checkedKeysLsKey, []),
-    _addressBookmarks: '[]',
-    _addressBookmarksLocal: ls.getItem(localAddrBookmarkLsKey) || '[]',
+    addressBookmarks: [],
+    addressBookmarksLocal: ls.getItemJSON(localAddrBookmarkLsKey, []),
     openResolutionEdit: false,
     resolutions: ls.getItemJSON(resolutionsLsKey, []),
 
@@ -92,7 +90,7 @@ export default () => {
     sftpSortSetting: ls.getItemJSON(sftpDefaultSortSettingKey, {
       local: {
         prop: 'modifyTime',
-        direction: 'asc'
+        direction: 'desc'
       },
       remote: {
         prop: 'modifyTime',
@@ -117,7 +115,6 @@ export default () => {
     _setting: '',
     settingItem: initSettingItem([], settingMap.bookmarks),
     settingTab: settingMap.bookmarks, // setting tab
-    autofocustrigger: Date.now(),
     bookmarkId: undefined,
     showModal: 0,
 
@@ -142,7 +139,7 @@ export default () => {
     },
 
     // quick commands
-    _quickCommands: '[]',
+    quickCommands: [],
     quickCommandId: '',
     openQuickCommandBar: false,
     pinnedQuickCommandBar: false,

package/client/store/item.js

@@ -3,11 +3,11 @@
  */
 
 import { find } from 'lodash-es'
+import deepCopy from 'json-deep-copy'
 import {
   settingMap
 } from '../common/constants'
 import getInitItem from '../common/init-setting-item'
-import { update, remove, dbNames } from '../common/db'
 
 export default Store => {
   Store.prototype.addItem = function (item, type) {
@@ -16,22 +16,8 @@ export default Store => {
 
   Store.prototype.addItems = function (objs, type) {
     const { store } = window
-    let items = store.getItems(type)
-    items = [
-      ...objs,
-      ...items
-    ]
-    store.setItems(type, items)
-    if (dbNames.includes(type)) {
-      store.batchDbAdd(
-        objs.map(obj => {
-          return {
-            db: type,
-            obj
-          }
-        })
-      )
-    }
+    const items = store.getItems(type)
+    items.push(...objs)
   }
 
   Store.prototype.editItem = function (id, updates, type) {
@@ -42,31 +28,25 @@ export default Store => {
       return
     }
     Object.assign(item, updates)
-    store.setItems(type, items)
-    if (dbNames.includes(type)) {
-      update(id, updates, type, false)
-    }
   }
 
   Store.prototype.delItem = function ({ id }, type) {
     const { store } = window
-    const items = store.getItems(type).filter(t => {
-      return t.id !== id
-    })
-    store.setItems(type, items)
-    if (dbNames.includes(type)) {
-      remove(type, id)
+    const items = store.getItems(type)
+    const index = items.findIndex(t => t.id === id)
+    if (index < 0) {
+      return
     }
+    items.splice(index, 1)
   }
 
   Store.prototype.delItems = function (ids, type) {
     const { store } = window
-    const items = store.getItems(type).filter(t => {
-      return !ids.includes(t.id)
-    })
-    store.setItems(type, items)
-    if (dbNames.includes(type)) {
-      ids.map(id => remove(type, id))
+    const items = store.getItems(type)
+    for (let i = items.length - 1; i >= 0; i--) {
+      if (ids.includes(items[i].id)) {
+        items.splice(i, 1)
+      }
     }
   }
 
@@ -83,22 +63,37 @@ export default Store => {
   Store.prototype.getSidebarList = function (type) {
     const { store } = window
     if (type === settingMap.terminalThemes) {
-      return [
+      return deepCopy([
         ...store.getTerminalThemes(),
         ...store.itermThemes
-      ].sort(window.store.sortTheme)
+      ]).sort(window.store.sortTheme)
     }
-    return store.getItems(type)
+    return deepCopy(store.getItems(type))
   }
 
   Store.prototype.getItems = function (type) {
     if (type === 'setting') {
       return window.store.setting
     }
-    return JSON.parse(this['_' + type] || [])
+    return window.store[type]
   }
 
-  Store.prototype.setItems = function (type, items) {
-    this['_' + type] = JSON.stringify(items)
+  Store.prototype.setItems = function (type, arr) {
+    window.store[type] = arr
+  }
+
+  Store.prototype.adjustOrder = function (type, fromId, toId) {
+    const { store } = window
+    const items = store.getItems(type)
+    const fromIndex = items.findIndex(t => t.id === fromId)
+    let toIndex = items.findIndex(t => t.id === toId)
+    if (fromIndex < 0 || toIndex < 0 || fromIndex === toIndex) {
+      return
+    }
+    if (fromIndex < toIndex) {
+      toIndex = toIndex - 1
+    }
+    const [removed] = items.splice(fromIndex, 1)
+    items.splice(toIndex, 0, removed)
   }
 }

package/client/store/load-data.js

@@ -13,6 +13,7 @@ import runIdle from '../common/run-idle'
 import { initWsCommon } from '../common/fetch-from-server'
 import safeParse from '../common/parse-json-safe'
 import initWatch from './watch'
+import { refsStatic } from '../components/common/ref'
 
 function getHost (argv, opts) {
   const arr = argv
@@ -185,11 +186,14 @@ export default (Store) => {
     await Promise.all(all)
       .then(arr => {
         for (const { name, data } of arr) {
-          ext['_' + name] = data || '[]'
+          const dt = JSON.parse(data || '[]')
+          refsStatic.add('oldState-' + name, dt)
+          ext[name] = dt
         }
       })
     ext.lastDataUpdateTime = await getData('lastDataUpdateTime') || 0
     Object.assign(store, ext)
+    await store.fixBookmarkGroups()
 
     store.checkDefaultTheme()
     store.loadFontList()

package/client/store/quick-command.js

@@ -5,20 +5,15 @@
 import {
   settingMap,
   qmSortByFrequencyKey,
-  terminalActions,
   isWin
 } from '../common/constants'
 import delay from '../common/wait'
 import generate from '../common/uid'
-import postMessage from '../common/post-msg'
 import * as ls from '../common/safe-local-storage'
 import { debounce } from 'lodash-es'
+import { refs } from '../components/common/ref'
 
 export default Store => {
-  Store.prototype.setQuickCommands = function (list) {
-    return window.store.setItems(settingMap.quickCommands, list)
-  }
-
   Store.prototype.addQuickCommand = function (
     qm
   ) {
@@ -34,12 +29,7 @@ export default Store => {
   }
 
   Store.prototype.runQuickCommand = function (cmd, inputOnly = false) {
-    postMessage({
-      action: terminalActions.quickCommand,
-      cmd,
-      inputOnly,
-      activeTabId: window.store.activeTabId
-    })
+    refs.get('term-' + window.store.activeTabId)?.runQuickCommand(cmd, inputOnly)
   }
 
   Store.prototype.runQuickCommandItem = debounce(async (id) => {

package/client/store/session.js

@@ -2,16 +2,15 @@
  * sessions not proper closed related functions
  */
 
-import { terminalActions } from '../common/constants'
 import { debounce } from 'lodash-es'
-import postMsg from '../common/post-msg'
+import { refs } from '../components/common/ref'
 
 export default Store => {
   Store.prototype.zoomTerminal = debounce(function (delta) {
-    postMsg({
-      action: terminalActions.zoom,
-      zoomValue: delta > 0 ? 1 : -1,
-      activeTabId: window.store.activeTabId
-    })
+    const term = refs.get('term-' + window.store.activeTabId)
+    if (!term) {
+      return
+    }
+    term.zoom(delta > 0 ? 1 : -1)
   }, 500)
 }