@electerm/electerm-react 1.60.16 → 1.60.29

package/client/components/tree-list/tree-list.jsx

@@ -8,21 +8,13 @@ import {
   CloseOutlined,
   LoadingOutlined
 } from '@ant-design/icons'
-import {
-  readClipboard,
-  cut,
-  hasBookmarkOrGroupInClipboardText
-} from '../../common/clipboard'
 import createName from '../../common/create-title'
 import InputAutoFocus from '../common/input-auto-focus'
-import { find, uniq, isEqual, filter, pick } from 'lodash-es'
+import { find, uniq, filter, pick } from 'lodash-es'
 import {
   maxBookmarkGroupTitleLength,
   defaultBookmarkGroupId,
-  settingMap,
-  commonActions,
-  copyBookmarkItemPrefix,
-  copyBookmarkGroupItemPrefix
+  settingMap
 } from '../../common/constants'
 import findParentBySel from '../../common/find-parent'
 import copy, { deepCopy } from 'json-deep-copy'
@@ -35,8 +27,7 @@ import './tree-list.styl'
 import TreeExpander from './tree-expander'
 import TreeListItem from './tree-list-item'
 import TreeSearch from './tree-search'
-
-const e = window.translate
+import MoveItemModal from './move-item-modal'
 
 export default class ItemListTree extends Component {
   constructor (props) {
@@ -46,6 +37,9 @@ export default class ItemListTree extends Component {
       keyword: '',
       parentId: '',
       showNewBookmarkGroupForm: false,
+      openMoveModal: false,
+      moveItem: null,
+      moveItemIsGroup: false,
       bookmarkGroupTitle: '',
       categoryTitle: '',
       categoryId: '',
@@ -53,6 +47,10 @@ export default class ItemListTree extends Component {
     }
   }
 
+  onSubmit = false
+
+  onSubmitEdit = false
+
   componentDidMount () {
     this.timer = setTimeout(() => {
       this.setState({
@@ -74,7 +72,14 @@ export default class ItemListTree extends Component {
 
   componentWillUnmount () {
     clearTimeout(this.timer)
-    window.removeEventListener('message', this.onContextAction)
+  }
+
+  onCancelMoveItem = () => {
+    this.setState({
+      openMoveModal: false,
+      moveItem: null,
+      moveItemIsGroup: false
+    })
   }
 
   filter = list => {
@@ -152,9 +157,7 @@ export default class ItemListTree extends Component {
     if (!categoryTitle) {
       return
     }
-    const bookmarkGroups = copy(
-      this.props.bookmarkGroups
-    )
+    const { bookmarkGroups } = window.store
     const obj = find(
       bookmarkGroups,
       bg => bg.id === categoryId
@@ -166,27 +169,20 @@ export default class ItemListTree extends Component {
     this.setState({
       categoryId: ''
     })
-    const { store } = window
-    store.setBookmarkGroups(
-      bookmarkGroups
-    )
-    store.batchDbUpdate([{
-      id: categoryId,
-      db: 'bookmarkGroups',
-      upsert: false,
-      update: {
-        title: categoryTitle
-      }
-    }])
   }
 
   onClick = () => {
 
   }
 
-  onSubmit = false
-
-  onSubmitEdit = false
+  openMoveModal = (e, item, isGroup) => {
+    e.stopPropagation()
+    this.setState({
+      openMoveModal: true,
+      moveItem: item,
+      moveItemIsGroup: isGroup
+    })
+  }
 
   handleChangeBookmarkGroupTitle = e => {
     let { value } = e.target
@@ -233,19 +229,14 @@ export default class ItemListTree extends Component {
       parentId: ''
     }, () => {
       this.onSubmit = false
-      let bookmarkGroups = copy(
-        this.props.bookmarkGroups
-      )
+      const { bookmarkGroups } = window.store
       const newCat = {
         id: uid(),
         title: this.state.bookmarkGroupTitle,
         level: 2,
         bookmarkIds: []
       }
-      bookmarkGroups = [
-        newCat,
-        ...bookmarkGroups
-      ]
+      bookmarkGroups.unshift(newCat)
       const cat = find(
         bookmarkGroups,
         d => d.id === id
@@ -257,22 +248,6 @@ export default class ItemListTree extends Component {
         ...(cat.bookmarkGroupIds || []),
         newCat.id
       ]
-      const { store } = window
-      store.setBookmarkGroups(
-        bookmarkGroups
-      )
-      store.batchDbAdd([{
-        db: 'bookmarkGroups',
-        obj: newCat
-      }])
-      store.batchDbUpdate([{
-        upsert: false,
-        id,
-        update: {
-          bookmarkGroupIds: cat.bookmarkGroupIds
-        },
-        db: 'bookmarkGroups'
-      }])
     })
   }
 
@@ -345,137 +320,6 @@ export default class ItemListTree extends Component {
     )
   }
 
-  onCut = (item, isGroup) => {
-    const str = isGroup
-      ? copyBookmarkGroupItemPrefix
-      : copyBookmarkItemPrefix
-    const txt = str + item.id
-    cut(txt, createName(item))
-  }
-
-  onPaste = (item) => {
-    const str = readClipboard()
-    const id = str.split(':')[1]
-    const bookmarkGroups = copy(
-      this.props.bookmarkGroups
-    )
-    const from = bookmarkGroups.find(t => {
-      return t.bookmarkIds.includes(id)
-    })
-    from.bookmarkIds = from.bookmarkIds.filter(d => {
-      return d !== id
-    })
-    const to = bookmarkGroups.find(t => {
-      return t.id === item.id
-    })
-    if (!to.bookmarkIds) {
-      to.bookmarkIds = []
-    }
-    to.bookmarkIds = uniq(
-      [
-        ...to.bookmarkIds,
-        id
-      ]
-    )
-    const { store } = window
-    if (from) {
-      store.editBookmarkGroup(
-        from.id,
-        {
-          bookmarkIds: (from.bookmarkIds || []).filter(d => {
-            return d !== id
-          })
-        }
-      )
-    }
-    store.editBookmarkGroup(
-      item.id,
-      {
-        bookmarkIds: uniq(
-          [
-            ...(item.bookmarkIds || []),
-            id
-          ]
-        )
-      }
-    )
-  }
-
-  computePos = (e) => {
-    return {
-      left: e.clientX,
-      top: e.clientY
-    }
-  }
-
-  onContextAction = e => {
-    const {
-      action,
-      id,
-      args = [],
-      func
-    } = e.data || {}
-    if (action === commonActions.closeContextMenuAfter) {
-      window.removeEventListener('message', this.onContextAction)
-      return false
-    }
-    if (
-      action !== commonActions.clickContextMenu ||
-      id !== this.uid ||
-      !this[func]
-    ) {
-      return false
-    }
-    window.removeEventListener('message', this.onContextAction)
-    this[func](...args)
-  }
-
-  onContextMenu = (e, item, isGroup) => {
-    e.preventDefault()
-    if (this.props.staticList) {
-      return null
-    }
-    const menus = this.renderContextItems(item, isGroup)
-    this.uid = uid()
-    window.store.openContextMenu({
-      items: menus,
-      id: this.uid,
-      pos: this.computePos(e)
-    })
-    window.addEventListener('message', this.onContextAction)
-    this.closeNewGroupForm()
-  }
-
-  renderContextItems (item, isGroup) {
-    const res = []
-    const args = [copy(item), isGroup]
-    if (!isGroup) {
-      // res.push({
-      //   func: 'onCopy',
-      //   icon: 'CopyOutlined',
-      //   text: e('copy'),
-      //   args
-      // })
-      res.push({
-        func: 'onCut',
-        icon: 'FileExcelOutlined',
-        text: e('cut'),
-        args
-      })
-    }
-    const canPaste = hasBookmarkOrGroupInClipboardText()
-    if (isGroup) {
-      res.push({
-        func: 'onPaste',
-        icon: 'CopyOutlined',
-        text: e('paste'),
-        disabled: !canPaste,
-        args
-      })
-    }
-    return res
-  }
-
   editItem = (e, item, isGroup) => {
     e.stopPropagation()
     if (isGroup) {
@@ -604,9 +448,8 @@ export default class ItemListTree extends Component {
         0,
         dragItem
       )
-      return window.store.setState('bookmarkGroups', bookmarkGroups)
+      return
     }
-    const updates = []
     if (isGroupDrag) {
       const parentDrag = pidDragged
         ? bookmarkGroups.find(
@@ -617,14 +460,6 @@ export default class ItemListTree extends Component {
         parentDrag.bookmarkGroupIds = (parentDrag.bookmarkGroupIds || []).filter(
           id => id !== idDragged
         )
-        updates.push({
-          upsert: false,
-          id: parentDrag.id,
-          update: {
-            bookmarkGroupIds: parentDrag.bookmarkGroupIds
-          },
-          db: 'bookmarkGroups'
-        })
       }
       const parentDrop = pidDrop
         ? bookmarkGroups.find(
@@ -651,14 +486,6 @@ export default class ItemListTree extends Component {
         }
         arr.splice(index, 0, idDragged)
       }
-      updates.push({
-        upsert: false,
-        id: parentDrop.id,
-        update: {
-          bookmarkGroupIds: parentDrop.bookmarkGroupIds
-        },
-        db: 'bookmarkGroups'
-      })
     } else {
       const parentDrag = bookmarkGroups.find(
         item => item.id === pidDragged
@@ -669,14 +496,6 @@ export default class ItemListTree extends Component {
       parentDrag.bookmarkIds = (parentDrag.bookmarkIds || []).filter(
         id => id !== idDragged
       )
-      updates.push({
-        upsert: false,
-        id: parentDrag.id,
-        update: {
-          bookmarkIds: parentDrag.bookmarkIds
-        },
-        db: 'bookmarkGroups'
-      })
       const parentDrop = isGroupDrop
         ? bookmarkGroups.find(
           item => item.id === idDrop
@@ -702,14 +521,6 @@ export default class ItemListTree extends Component {
         }
         arr.splice(index, 0, idDragged)
       }
-      updates.push({
-        upsert: false,
-        id: parentDrop.id,
-        update: {
-          bookmarkIds: parentDrop.bookmarkIds
-        },
-        db: 'bookmarkGroups'
-      })
     }
     if (
       isGroupDrag &&
@@ -720,18 +531,8 @@ export default class ItemListTree extends Component {
       if (i >= 0) {
         const item = bookmarkGroups[i]
         item.level = 2
-        updates.push({
-          upsert: false,
-          id: item.id,
-          update: {
-            level: item.level
-          },
-          db: 'bookmarkGroups'
-        })
       }
     }
-    window.store.batchDbUpdate(updates)
-    return window.store.setState('bookmarkGroups', bookmarkGroups)
   }
 
   editCategory = () => {
@@ -757,9 +558,7 @@ export default class ItemListTree extends Component {
   duplicateItem = (e, item) => {
     e.stopPropagation()
     const { addItem } = window.store
-    const bookmarkGroups = copy(
-      this.props.bookmarkGroups
-    )
+    const { bookmarkGroups } = this.props
 
     const newbookmark = copy(item)
     newbookmark.id = uid()
@@ -779,14 +578,16 @@ export default class ItemListTree extends Component {
     addItem(newbookmark, settingMap.bookmarks)
     // update bookmark groups
     this.updateBookmarkGroups(
-      bookmarkGroups,
       newbookmark,
       categoryId
     )
     this.props.onClickItem(newbookmark)
   }
 
-  updateBookmarkGroups = (bookmarkGroups, bookmark, categoryId) => {
+  updateBookmarkGroups = (bookmark, categoryId) => {
+    const {
+      bookmarkGroups
+    } = window.store
     let index = bookmarkGroups.findIndex(
       bg => bg.id === categoryId
     )
@@ -795,48 +596,20 @@ export default class ItemListTree extends Component {
         bg => bg.id === defaultBookmarkGroupId
       )
     }
-    const updates = []
     const bid = bookmark.id
     const bg = bookmarkGroups[index]
-    const old = copy(bg.bookmarkIds)
     if (!bg.bookmarkIds.includes(bid)) {
       bg.bookmarkIds.unshift(bid)
     }
     bg.bookmarkIds = uniq(bg.bookmarkIds)
-    if (!isEqual(old, copy(bg.bookmarkIds))) {
-      updates.push({
-        id: bg.id,
-        db: 'bookmarkGroups',
-        upsert: false,
-        update: {
-          bookmarkIds: bg.bookmarkIds
-        }
-      })
-    }
-    bookmarkGroups = bookmarkGroups.map((bg, i) => {
+    bookmarkGroups.forEach((bg, i) => {
       if (i === index) {
-        return bg
+        return
       }
-      const old = copy(bg.bookmarkIds)
       bg.bookmarkIds = bg.bookmarkIds.filter(
         g => g !== bid
       )
-      if (!isEqual(old, copy(bg.bookmarkIds))) {
-        updates.push({
-          id: bg.id,
-          db: 'bookmarkGroups',
-          upsert: false,
-          update: {
-            bookmarkIds: bg.bookmarkIds
-          }
-        })
-      }
-      return bg
     })
-    window.store.setBookmarkGroups(
-      bookmarkGroups
-    )
-    window.store.batchDbUpdate(updates)
   }
 
   findBookmarkByTitle = (bookmarks, oldBookmark) => {
@@ -861,7 +634,7 @@ export default class ItemListTree extends Component {
         [
           'del',
           'openAll',
-          'onContextMenu',
+          'openMoveModal',
           'editItem',
           'addSubCat',
           'onSelect',
@@ -875,13 +648,7 @@ export default class ItemListTree extends Component {
       ...pick(
         this.state,
         [
-          'keyword',
-          'openAll',
-          'onContextMenu',
-          'editItem',
-          'addSubCat',
-          'onSelect',
-          'duplicateItem'
+          'keyword'
         ]
       )
     }
@@ -1024,7 +791,7 @@ export default class ItemListTree extends Component {
   }
 
   render () {
-    const { ready } = this.state
+    const { ready, openMoveModal, moveItem, moveItemIsGroup } = this.state
     if (!ready) {
       return (
         <div className='pd3 aligncenter'>
@@ -1038,6 +805,13 @@ export default class ItemListTree extends Component {
       staticList,
       listStyle = {}
     } = this.props
+    const moveProps = {
+      openMoveModal,
+      moveItem,
+      moveItemIsGroup,
+      bookmarkGroups,
+      onCancelMoveItem: this.onCancelMoveItem
+    }
     const level1Bookgroups = ready
       ? bookmarkGroups.filter(
         d => !d.level || d.level < 2
@@ -1045,6 +819,7 @@ export default class ItemListTree extends Component {
       : []
     return (
       <div className={`tree-list item-type-${type}`}>
+        <MoveItemModal {...moveProps} />
         {
           staticList
             ? null

package/client/components/vnc/vnc-session.jsx

@@ -1,3 +1,4 @@
+import { createRef } from 'react'
 import RdpSession from '../rdp/rdp-session'
 import { createTerm } from '../terminal/terminal-apis'
 import deepCopy from 'json-deep-copy'
@@ -35,6 +36,8 @@ export default class VncSession extends RdpSession {
     }
   }
 
+  domRef = createRef()
+
   componentDidMount () {
     this.remoteInit()
   }
@@ -203,8 +206,7 @@ export default class VncSession extends RdpSession {
   }
 
   getDom = () => {
-    const id = 'canvas_' + this.props.tab.id
-    return document.getElementById(id)
+    return this.domRef.current
   }
 
   handleReInit = () => {
@@ -282,7 +284,7 @@ export default class VncSession extends RdpSession {
           <div
             {...divProps}
             className='vnc-session-wrap session-v-wrap'
-            id={'canvas_' + this.props.tab.id}
+            ref={this.domRef}
           />
           {this.renderConfirm()}
         </div>

package/client/store/app-upgrade.js

@@ -2,14 +2,11 @@
  * app upgrade
  */
 
-import { commonActions } from '../common/constants'
+import { refsStatic } from '../components/common/ref'
 
 export default Store => {
   Store.prototype.onCheckUpdate = (noSkip = true) => {
-    window.postMessage({
-      action: commonActions.appUpdateCheck,
-      noSkip
-    }, '*')
+    refsStatic.get('upgrade')?.appUpdateCheck(noSkip)
   }
   Store.prototype.getProxySetting = function () {
     const {

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,17 +45,17 @@ export default Store => {
     }
   }
 
-  Store.prototype.delBookmarkGroup = function ({ id }) {
+  Store.prototype.delBookmarkGroup = action(function ({ id }) {
     const { store } = window
     if (id === defaultBookmarkGroupId) {
       return
     }
-    let bookmarkGroups = store.bookmarkGroups
+    let { bookmarkGroups } = store
     const tobeDel = find(bookmarkGroups, bg => bg.id === id)
     if (!tobeDel) {
       return
     }
-    let groups = [tobeDel]
+    const groups = [tobeDel]
     if (
       tobeDel.level !== 2 &&
       tobeDel.bookmarkGroupIds &&
@@ -63,13 +64,9 @@ export default Store => {
       const childs = bookmarkGroups.filter(
         bg => tobeDel.bookmarkGroupIds.includes(bg.id)
       )
-      groups = [
-        ...groups,
-        ...childs
-      ]
+      groups.push(...childs)
     }
     const groupIds = groups.map(g => g.id)
-    const updates = []
     const defaultCatIndex = tobeDel.level !== 2
       ? bookmarkGroups.findIndex(
         g => g.id === defaultBookmarkGroupId
@@ -80,33 +77,82 @@ export default Store => {
     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
-          }
-        })
+        def.bookmarkIds.push(...g.bookmarkIds)
       }
     }
     bookmarkGroups = bookmarkGroups.filter(t => {
       return !groupIds.includes(t.id)
     })
-    store.batchDbUpdate(updates)
-    store.batchDbDel(groupIds.map(id => {
-      return {
-        id,
-        db: 'bookmarkGroups'
-      }
-    }))
-    store.setBookmarkGroups(bookmarkGroups)
     if (id === store.currentBookmarkGroupId) {
       store.currentBookmarkGroupId = ''
     }
+  })
+
+  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 = []
+      }
+    }
+
+    // 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])
+        ]
+      }
+    }
+
+    // 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)])
+      ]
+    }
   }
 }