@electerm/electerm-react 1.34.30

package/client/store/event.js

@@ -0,0 +1,70 @@
+/**
+ * extend store
+ */
+
+import postMessage from '../common/post-msg'
+import { commonActions } from '../common/constants'
+
+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'
+    })
+  }
+
+  Store.prototype.blur = function () {
+    window.focused = false
+    postMessage({
+      type: 'blur'
+    })
+  }
+
+  Store.prototype.onBlur = function () {
+    window.focused = false
+  }
+
+  Store.prototype.selectall = function () {
+    document.activeElement &&
+    document.activeElement.select &&
+    document.activeElement.select()
+    postMessage({
+      event: 'selectall',
+      id: window.store.activeTerminalId
+    })
+  }
+
+  Store.prototype.triggerResize = function () {
+    window.dispatchEvent(new window.Event('resize'))
+  }
+
+  Store.prototype.toggleTermFullscreen = function (terminalFullScreen) {
+    window.store.terminalFullScreen = terminalFullScreen
+    setTimeout(window.store.triggerResize, 500)
+  }
+}

package/client/store/index.js

@@ -0,0 +1,335 @@
+/**
+ * central state store powered by manate - https://github.com/tylerlong/manate
+ */
+
+import { manage } from 'manate'
+import initState from './init-state'
+import loadDataExtend from './load-data'
+import dbUpgradeExtend from './db-upgrade'
+import eventExtend from './event'
+import syncExtend from './sync'
+import appUpgrdeExtend from './app-upgrade'
+import bookmarkGroupExtend from './bookmark-group'
+import bookmarkExtend from './bookmark'
+import commonExtend from './common'
+import contextMenuExtend from './context-menu'
+import itemExtend from './item'
+import quickCommandExtend from './quick-command'
+import sessionExtend from './session'
+import settingExtend from './setting'
+import sidebarExtend from './sidebar'
+import sysMenuExtend from './system-menu'
+import tabExtend from './tab'
+import uiThemeExtend from './ui-theme'
+import terminalThemeExtend from './terminal-theme'
+import transferHistoryExtend from './transfer-history'
+import batchInputHistory from './batch-input-history'
+import transferExtend from './transfer-list'
+import addressBookmarkExtend from './address-bookmark'
+
+import { uniq } from 'lodash-es'
+import copy from 'json-deep-copy'
+import {
+  settingMap,
+  sidebarWidth,
+  sidebarPanelWidth,
+  paneMap
+} from '../common/constants'
+import getInitItem from '../common/init-setting-item'
+import {
+  theme
+} from 'antd'
+
+function getReverseColor (hex) {
+  // Check if the input is a valid hex color code
+  if (!/^#[0-9a-fA-F]{6}$/.test(hex)) {
+    return '#0088cc'
+  }
+  // Convert the hex color code to an integer
+  const num = parseInt(hex.slice(1), 16)
+  // Bitwise XOR the integer with 0xFFFFFF to get the reverse color
+  const reverse = num ^ 0xFFFFFF
+  // Convert the reverse color to a hex string and pad with zeros if needed
+  return '#' + reverse.toString(16).padStart(6, '0')
+}
+
+function expandShorthandColor (color) {
+  if (color.length === 4) {
+    return '#' + color[1] + color[1] + color[2] + color[2] + color[3] + color[3]
+  }
+  return color
+}
+
+function isColorDark (_color) {
+  let color = expandShorthandColor(_color)
+  if (color.charAt(0) === '#') {
+    color = color.slice(1) // Remove the '#' if present
+  }
+  const r = parseInt(color.substr(0, 2), 16)
+  const g = parseInt(color.substr(2, 2), 16)
+  const b = parseInt(color.substr(4, 2), 16)
+
+  // Formula to determine brightness
+  const brightness = (r * 299 + g * 587 + b * 114) / 1000
+
+  // Decide based on brightness threshold
+  return brightness < 128 // You can adjust this threshold as needed
+}
+
+class Store {
+  constructor () {
+    Object.assign(
+      this,
+      initState
+    )
+  }
+
+  get width () {
+    return window.store.innerWidth - sidebarWidth -
+      (window.store.pinned ? sidebarPanelWidth : 0)
+  }
+
+  get currentQuickCommands () {
+    const { currentTab } = this
+    const quickCommands = window.store.getQuickCommands()
+    const currentTabQuickCommands = (
+      currentTab.quickCommands || []
+    ).map((d, i) => {
+      return {
+        ...d,
+        id: 'tab-qm-' + currentTab.id + '#' + i
+      }
+    })
+    return [
+      ...currentTabQuickCommands,
+      ...quickCommands
+    ]
+  }
+
+  get currentTab () {
+    const {
+      currentTabId
+    } = this
+    const tabs = window.store.getTabs()
+    const tab = tabs.find(t => t.id === currentTabId)
+    if (!tab) {
+      return false
+    }
+    return tab
+  }
+
+  get inActiveTerminal () {
+    const { store } = window
+    return !store.showModal &&
+      store.termFocused &&
+      store.currentTab &&
+      (
+        store.currentTab.pane === paneMap.ssh ||
+        store.currentTab.pane === paneMap.terminal
+      )
+  }
+
+  get quickCommandTags () {
+    const quickCommands = window.store.getQuickCommands()
+    return uniq(
+      quickCommands.reduce((p, q) => {
+        return [
+          ...p,
+          ...(q.labels || [])
+        ]
+      }, [])
+    )
+  }
+
+  get expandedKeys () {
+    return JSON.parse(window.store._expandedKeys || '[]')
+  }
+
+  get checkedKeys () {
+    return JSON.parse(window.store._checkedKeys || '[]')
+  }
+
+  get isTransporting () {
+    return window.store.getTabs().some(t => t.isTransporting)
+  }
+
+  get addressBookmarks () {
+    return JSON.parse(window.store._addressBookmarks || '[]')
+  }
+
+  get addressBookmarksLocal () {
+    return JSON.parse(window.store._addressBookmarksLocal || '[]')
+  }
+
+  get settingSidebarList () {
+    const {
+      settingTab
+    } = this
+    const arr = window.store.getSidebarList(settingTab)
+    const initItem = getInitItem(arr, settingTab)
+    return settingTab === settingMap.history
+      ? arr
+      : [
+          copy(initItem),
+          ...arr
+        ]
+  }
+
+  get termSearchOptions () {
+    const {
+      store
+    } = window
+    const theme = store.getThemeConfig()
+    return {
+      ...JSON.parse(window.store._termSearchOptions),
+      decorations: {
+        activeMatchColorOverviewRuler: theme.selectionBackground,
+        matchBackground: theme.background,
+        matchOverviewRuler: theme.selectionBackground,
+        matchBorder: getReverseColor(theme.background)
+      }
+    }
+  }
+
+  get tabTitles () {
+    return window.store.getTabs().map(d => d.title).join('#')
+  }
+
+  get sshConfigItems () {
+    return JSON.parse(window.store._sshConfigItems || '[]')
+  }
+
+  get itermThemes () {
+    return JSON.parse(window.store._itermThemes || '[]')
+  }
+
+  get history () {
+    return JSON.parse(window.store._history || '[]')
+  }
+
+  get bookmarks () {
+    return JSON.parse(window.store._bookmarks || '[]')
+  }
+
+  get bookmarkGroups () {
+    return JSON.parse(window.store._bookmarkGroups || '[]')
+  }
+
+  get tabs () {
+    return JSON.parse(window.store._tabs || '[]')
+  }
+
+  get fileTransfers () {
+    return JSON.parse(window.store._fileTransfers || '[]')
+  }
+
+  get transferHistory () {
+    return JSON.parse(window.store._transferHistory || '[]')
+  }
+
+  get quickCommands () {
+    return JSON.parse(window.store._quickCommands || '[]')
+  }
+
+  get terminalThemes () {
+    return JSON.parse(window.store._terminalThemes || '[]')
+  }
+
+  get serials () {
+    return JSON.parse(window.store._serials || '[]')
+  }
+
+  get setting () {
+    return JSON.parse(window.store._setting || '[]')
+  }
+
+  get config () {
+    return JSON.parse(window.store._config || '{}')
+  }
+
+  get sftpSortSetting () {
+    return JSON.parse(window.store._sftpSortSetting)
+  }
+
+  get fonts () {
+    return JSON.parse(window.store._fonts || '[]')
+  }
+
+  get onOperation () {
+    const {
+      store
+    } = window
+    return store.showModal ||
+      store.termSearchOpen ||
+      store.showInfoModal ||
+      store.showEditor ||
+      store.showFileModal
+  }
+
+  get topMenuHeight () {
+    return window.store.config.useSystemTitleBar ? 0 : 15
+  }
+
+  get tabsHeight () {
+    return window.store.config.useSystemTitleBar ? 45 : 56
+  }
+
+  get langs () {
+    return JSON.parse(window.store._langs)
+  }
+
+  get upgradeInfo () {
+    return JSON.parse(window.store._upgradeInfo)
+  }
+
+  get settingItem () {
+    return JSON.parse(window.store._settingItem)
+  }
+
+  get uiThemeConfig () {
+    const { store } = window
+    const themeConf = store.getUiThemeConfig()
+    return {
+      token: {
+        borderRadius: 3,
+        colorPrimary: themeConf.primary,
+        colorBgBase: themeConf.main,
+        colorError: themeConf.error,
+        colorInfo: themeConf.info,
+        colorSuccess: themeConf.success,
+        colorWarning: themeConf.warn,
+        colorTextBase: themeConf.text,
+        colorLink: themeConf['text-light']
+      },
+      algorithm: isColorDark(themeConf.main) ? theme.darkAlgorithm : theme.defaultAlgorithm
+    }
+  }
+}
+
+loadDataExtend(Store)
+eventExtend(Store)
+dbUpgradeExtend(Store)
+syncExtend(Store)
+appUpgrdeExtend(Store)
+bookmarkGroupExtend(Store)
+bookmarkExtend(Store)
+commonExtend(Store)
+contextMenuExtend(Store)
+itemExtend(Store)
+quickCommandExtend(Store)
+sessionExtend(Store)
+settingExtend(Store)
+sidebarExtend(Store)
+sysMenuExtend(Store)
+tabExtend(Store)
+terminalThemeExtend(Store)
+uiThemeExtend(Store)
+transferHistoryExtend(Store)
+batchInputHistory(Store)
+transferExtend(Store)
+addressBookmarkExtend(Store)
+
+const store = manage(new Store())
+
+window.store = store
+export default store

package/client/store/init-state.js

@@ -0,0 +1,191 @@
+/**
+ * init static state
+ */
+
+import {
+  settingMap,
+  defaultBookmarkGroupId,
+  newBookmarkIdPrefix,
+  fileOperationsMap,
+  syncTypes,
+  settingSyncId,
+  infoTabs,
+  openedSidebarKey,
+  sidebarPinnedKey,
+  sftpDefaultSortSettingKey,
+  batchInputLsKey,
+  expandedKeysLsKey,
+  checkedKeysLsKey,
+  localAddrBookmarkLsKey
+} from '../common/constants'
+import { buildDefaultThemes, buildNewTheme } from '../common/terminal-theme'
+import * as ls from '../common/safe-local-storage'
+
+const { prefix } = window
+const t = prefix('terminalThemes')
+const e = prefix('control')
+const newQuickCommand = 'newQuickCommand'
+const q = prefix('quickCommands')
+const ss = prefix('settingSync')
+
+function getDefaultBookmarkGroups (bookmarks) {
+  return [
+    JSON.stringify({
+      title: t(defaultBookmarkGroupId),
+      id: defaultBookmarkGroupId,
+      bookmarkIds: bookmarks.map(d => d.id)
+    })
+  ]
+}
+
+export const getInitItem = (arr, tab) => {
+  if (tab === settingMap.history) {
+    return arr[0] || {}
+  } else if (tab === settingMap.bookmarks) {
+    return { id: newBookmarkIdPrefix + ':' + (Date.now()), title: '' }
+  } else if (tab === settingMap.setting) {
+    return { id: '', title: e('common') }
+  } else if (tab === settingMap.terminalThemes) {
+    return buildNewTheme()
+  } else if (tab === settingMap.quickCommands) {
+    return {
+      id: '',
+      name: q(newQuickCommand)
+    }
+  }
+}
+
+export default {
+  // common
+  wsInited: false,
+  configLoaded: false,
+  loadTime: 0,
+  lastDataUpdateTime: 0,
+  _tabs: '[]',
+  currentTabId: '',
+  termFocused: false,
+  _history: '[]',
+  _bookmarks: '[]',
+  _bookmarkGroups: JSON.stringify(
+    getDefaultBookmarkGroups([])
+  ),
+  _config: '{}',
+  _terminalThemes: JSON.stringify([
+    buildDefaultThemes()
+  ]),
+  _itermThemes: '[]',
+  currentBookmarkGroupId: defaultBookmarkGroupId,
+  _expandedKeys: ls.getItem(expandedKeysLsKey) || JSON.stringify([
+    defaultBookmarkGroupId
+  ]),
+  bookmarkSelectMode: false,
+  _checkedKeys: ls.getItem(checkedKeysLsKey) || '[]',
+  _addressBookmarks: '[]',
+  _addressBookmarksLocal: ls.getItem(localAddrBookmarkLsKey) || '[]',
+
+  // init session control
+  selectedSessions: [],
+  sessionModalVisible: false,
+
+  // sftp
+  fileOperation: fileOperationsMap.cp, // cp or mv
+  transferTab: 'transfer',
+  _transferHistory: '[]',
+  _fileTransfers: '[]',
+  _sftpSortSetting: ls.getItem(sftpDefaultSortSettingKey) || JSON.stringify({
+    local: {
+      prop: 'modifyTime',
+      direction: 'asc'
+    },
+    remote: {
+      prop: 'modifyTime',
+      direction: 'desc'
+    }
+  }),
+
+  // for settings related
+  _setting: JSON.stringify([
+    {
+      id: settingSyncId,
+      title: ss('settingSync')
+    }
+  ]),
+  _settingItem: JSON.stringify(getInitItem([], settingMap.bookmarks)),
+  settingTab: settingMap.bookmarks, // setting tab
+  autofocustrigger: Date.now(),
+  bookmarkId: undefined,
+  showModal: 0,
+  activeTerminalId: '',
+
+  // setting sync related
+  isSyncingSetting: false,
+  isSyncUpload: false,
+  isSyncDownload: false,
+  syncSetting: {},
+  syncType: syncTypes.github,
+  _fonts: '[]',
+
+  // term search
+  termSearchOpen: false,
+  termSearch: '',
+  termSearchMatchCount: 0,
+  termSearchMatchIndex: 0,
+  _termSearchOptions: JSON.stringify({
+    caseSensitive: false,
+    wholeWord: false,
+    regex: false,
+    decorations: {
+      activeMatchColorOverviewRuler: 'yellow'
+    }
+  }),
+
+  // quick commands
+  _quickCommands: '[]',
+  quickCommandId: '',
+  openQuickCommandBar: false,
+  pinnedQuickCommandBar: false,
+
+  // sidebar
+  openedSideBar: ls.getItem(openedSidebarKey),
+  menuOpened: false,
+  pinned: ls.getItem(sidebarPinnedKey) === 'true',
+
+  // info/help modal
+  showInfoModal: false,
+  infoModalTab: infoTabs.info,
+  commandLineHelp: '',
+
+  // editor
+  showEditor: false,
+
+  // file/info modal
+  showFileModal: false,
+
+  // update
+  _upgradeInfo: '{}',
+
+  // serial list related
+  _serials: '[]',
+  loaddingSerials: false,
+
+  // transfer list
+  transports: [],
+
+  _sshConfigItems: '[]',
+
+  appPath: '',
+  exePath: '',
+  isPortable: false,
+  installSrc: '',
+
+  _langs: '[]',
+
+  // batch inputs
+  batchInputs: ls.getItemJSON(batchInputLsKey, []),
+
+  // ui
+  innerWidth: window.innerWidth,
+  height: 500,
+  isMaximized: window.pre.runSync('isMaximized'),
+  terminalFullScreen: false
+}

package/client/store/item.js

@@ -0,0 +1,120 @@
+/**
+ * common db op
+ */
+
+import { find } from 'lodash-es'
+import {
+  maxHistory,
+  settingMap
+} from '../common/constants'
+import getInitItem from '../common/init-setting-item'
+import { update, remove, dbNames } from '../common/db'
+import copy from 'json-deep-copy'
+
+export default Store => {
+  Store.prototype.removeOldHistoryFromDb = function (items) {
+    const arr = items.slice(maxHistory).map(k => {
+      return {
+        db: 'history',
+        id: k.id
+      }
+    })
+    window.store.batchDbDel(arr)
+  }
+
+  Store.prototype.addItem = function (item, type) {
+    return window.store.addItems([item], type)
+  }
+
+  Store.prototype.addItems = function (objs, type) {
+    const { store } = window
+    let items = store.getItems(type)
+    items = [
+      ...objs,
+      ...items
+    ]
+    if (type === settingMap.history && items.length > maxHistory) {
+      store.removeOldHistoryFromDb(
+        copy(items)
+      )
+      items.slice(0, maxHistory)
+    }
+    store.setItems(type, items)
+    if (dbNames.includes(type)) {
+      store.batchDbAdd(
+        objs.map(obj => {
+          return {
+            db: type,
+            obj
+          }
+        })
+      )
+    }
+  }
+
+  Store.prototype.editItem = function (id, updates, type) {
+    const { store } = window
+    const items = store.getItems(type)
+    const item = find(items, t => t.id === id)
+    if (!item) {
+      return
+    }
+    // let index = findIndex(items, t => t.id === id)
+    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)
+    }
+  }
+
+  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))
+    }
+  }
+
+  Store.prototype.onDelItem = function (item, type) {
+    const { store } = window
+    if (item.id === store.settingItem.id) {
+      store.setSettingItem(getInitItem(
+        store.getItems(type),
+        type
+      ))
+    }
+  }
+
+  Store.prototype.getSidebarList = function (type) {
+    const { store } = window
+    if (type === settingMap.terminalThemes) {
+      return [
+        ...store.getTerminalThemes(),
+        ...store.itermThemes
+      ].sort(window.store.sortTheme)
+    }
+    return store.getItems(type)
+  }
+
+  Store.prototype.getItems = function (type) {
+    return JSON.parse(this['_' + type] || [])
+  }
+
+  Store.prototype.setItems = function (type, items) {
+    this['_' + type] = JSON.stringify(items)
+  }
+}